Merge pull request diffblue#545 from diffblue/jd/feature/make_di_java_compile

NathanJPhillips · web-flow · commit 78e73923a00d · 2018-08-28T19:49:52.000+01:00
[SEC-604] Fix DI compilation errors
diff --git a/env-model-generator/src/createEntryPoint.ts b/env-model-generator/src/createEntryPoint.ts
@@ -0,0 +1,62 @@
+import * as fs from "fs-extra";
+import { ConfigParseError } from "./configParseError";
+import { Argument, EntryPoint, EntryPointConfig } from "./entryPointConfig";
+import { Cast, Class, Declaration, Expression, FnCall, FnStatement, Method, Null, Statement, StringConstant } from "./javaCode";
+import { Repository } from "./model";
+import { makeIdentifier } from "./utils";
+
+export async function processEntryPointConfigAsync(filePath: string): Promise<Class> {
+  let json: string;
+  try {
+    json = await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    throw new ConfigParseError(`Can't open input file '${filePath}': ${err.message}`);
+  }
+  const entryPointConfig: EntryPointConfig = JSON.parse(json);
+  return createEntryPointClass(entryPointConfig.entryPoints);
+}
+
+export function createEntryPointClass(entryPoints: EntryPoint[]): Class {
+  return new Class(
+    "com.diffblue.security", "public", "SyntheticEntryPoints", undefined, [], entryPoints.map(createEntryPoint));
+}
+
+function createEntryPoint(entryPoint: EntryPoint): Method {
+  let isContextRequired = false;
+  let mainClassConstruction;
+  [ mainClassConstruction, isContextRequired ] = getClassConstructionCall(entryPoint.className, isContextRequired);
+  let argConstructionCalls;
+  [ argConstructionCalls, isContextRequired ] = entryPoint.method.arguments.reduce(
+    function ([ args, icr ]: [ Expression[], boolean ], arg: Argument): [ Expression[], boolean ] {
+      let argConstructionCall;
+      [ argConstructionCall, icr ] = getClassConstructionCall(arg.type, icr);
+      return [ [ ...args, argConstructionCall ], icr ];
+    },
+    <[ Expression[], boolean ]>[ [], isContextRequired ]);
+
+  const statements: Statement[] = [];
+  if (isContextRequired)
+    statements.push(
+      new Declaration("org.springframework.context.support.ClassPathXmlApplicationContext", "appContext",
+        new FnCall("new org.springframework.context.support.ClassPathXmlApplicationContext", [])));
+
+  statements.push(new Declaration(entryPoint.className, "mainClass", mainClassConstruction));
+  const entryPointCall = new FnCall(`mainClass.${entryPoint.method.name}`, argConstructionCalls);
+  // TODO: For particular types where we need an artificlal sink, test entryPoint.method.returnType, then insert a Declaration and a call to the sink
+  statements.push(new FnStatement(entryPointCall));
+
+  return new Method(`public static void ${makeIdentifier(entryPoint.className)}_${makeIdentifier(entryPoint.method.name)}_entryPoint()`,
+    statements, ["Exception"]);
+}
+
+function getClassConstructionCall(className: string, isContextRequired: boolean): [ Expression, boolean ] {
+  const classBeanId = Repository.tryGetIdByClass(className);
+  if (classBeanId === undefined) {
+    return [ new FnCall("org.cprover.CProver.nondetWithoutNull", [new Null()]), isContextRequired ];
+  } else {
+    const classBean = Repository.tryGet(classBeanId);
+    if (classBean === undefined)
+      throw new Error("Bean with identifier returned by tryGetIdByClass does not exist");
+    return [ new Cast(className, new FnCall("appContext.getBean", [ new StringConstant(classBean.name) ])), true ];
+  }
+}
diff --git a/env-model-generator/src/entryPointConfig.ts b/env-model-generator/src/entryPointConfig.ts
@@ -0,0 +1,19 @@
+export interface EntryPointConfig {
+  entryPoints: EntryPoint[];
+}
+
+export interface EntryPoint {
+  className: string;
+  method: Method;
+}
+
+export interface Method {
+  name: string;
+  arguments: Argument[];
+  returnType: string;
+  signature: string;
+}
+
+export interface Argument {
+  type: string;
+}
diff --git a/env-model-generator/src/env-model-generator.ts b/env-model-generator/src/env-model-generator.ts
@@ -4,11 +4,10 @@
 
 import * as program from "commander";
 import * as fs from "fs-extra";
-import * as _ from "lodash";
 import * as pathUtils from "path";
-import { BlankLine, CatchBlock, Class, FnCall, IfThenElse, Method, Null, Return, Statement, StringConstant, TryCatch } from "./javaCode";
-import * as model from "./model";
-import parseSpringConfigFiles from "./parserDriver";
+import { processEntryPointConfigAsync } from "./createEntryPoint";
+import { Class } from "./javaCode";
+import parseSpringConfigFiles, { createApplicationContextClass } from "./parserDriver";
 import { createPath } from "./utils";
 
 function collectOption(value: string, collection?: string[]) {
@@ -21,7 +20,8 @@ function collectOption(value: string, collection?: string[]) {
 program
   .version("0.0.1")
   .arguments("<input-file>")
-  .option("-i --input-file <path>", "Additional DI configuration file to read", collectOption)
+  .option("-i --di-input-file <path>", "Additional DI configuration file to read", collectOption)
+  .option("-e --entry-points-input-file <path>", "Entry point configuration file to read")
   .option("-o --output-path <output-path>", "Path to write output under")
   .description("Create code from DI configuration")
   .action(transformConfigFiles);
@@ -42,100 +42,63 @@ enum ReturnValue {
 
 async function transformConfigFiles(fileName: string, options: any) {
   let fileNames = [ fileName ];
-  if (options.inputFile)
-  fileNames = fileNames.concat(options.inputFile);
+  if (options.diInputFile)
+    fileNames = fileNames.concat(options.diInputFile);
   try {
     await parseSpringConfigFiles(fileNames);
   } catch (err) {
     console.error(`Error parsing config file: ${err.message}`);
     process.exit(ReturnValue.ParseError);
     return;
   }
-  const packageName = "org.springframework.context.support";
-  let output = `package ${packageName};\n\n`;
+  let applicationContext;
   try {
-    const applicationContext =
-      new Class(
-        "public", "ClassPathXmlApplicationContext", undefined, [ "org.springframework.context.ApplicationContext" ],
-        [
-          new Method(
-            "public ClassPathXmlApplicationContext(String[] args)",
-            []),
-          new Method(
-            "public Object getBean(String name)",
-            [
-              new TryCatch(
-                (<Statement[]>[]).concat(
-                  model.Repository.getNamed()
-                    .sort((a, b) => a.name < b.name ? -1 : a.name === b.name ? 0 : 1)
-                    .map((bean) =>
-                      new IfThenElse(
-                        new FnCall("name.equals", [ new StringConstant(bean.name) ]),
-                        [
-                          new Return(new FnCall(bean.getter, [])),
-                        ])),
-                  [...model.Repository.getAliases()].map(
-                    function ([ alias, beanId ]) {
-                      const bean = model.Repository.tryGet(beanId);
-                      if (bean === undefined)
-                        throw new Error("Found alias to bean that doesn't exist");
-                      return new IfThenElse(
-                        new FnCall("name.equals", [ new StringConstant(alias) ]),
-                        [
-                          new Return(new FnCall(bean.getter, [])),
-                        ]);
-                    }),
-                ),
-                [ new CatchBlock("Exception") ]),
-              new Return(new Null()),
-            ],
-            [],
-            [ "OverlayMethodImplementation" ]
-          ),
-          new BlankLine(),
-          new BlankLine(),
-          ..._.flatMap([...model.Repository.getAll()], (bean) => bean.javaMembers),
-          new BlankLine(),
-          ...model.PropertiesValue.utilityMethods(),
-          ...model.MapValue.utilityMethods(),
-          ...model.BeanValue.utilityMethods(),
-        ],
-        [ "OverlayClassImplementation" ]);
-    output += applicationContext.toString() + "\n";
+    applicationContext = createApplicationContextClass();
   } catch (err) {
     console.error(`Error converting to Java: ${err.message}`);
     process.exit(ReturnValue.CreateJavaError);
     return;
   }
+
+  if (options.outputPath && !fs.existsSync(options.outputPath)) {
+    console.error(`Given output folder '${options.outputPath}' does not exist`);
+    process.exit(ReturnValue.OutputFolderNotFound);
+    return;
+  }
+
   // Write out the generated Java
-  let outputPath = options.outputPath;
-  if (outputPath) {
-    if (!fs.existsSync(outputPath)) {
-      console.error(`Given output folder '${outputPath}' does not exist`);
-      process.exit(ReturnValue.OutputFolderNotFound);
-      return;
-    }
-    // Create folder to store it in based on the package name
-    const appContextFolder = pathUtils.join(...packageName.split("."));
+  await saveGeneratedFile(applicationContext, options);
+
+  if (options.entryPointsInputFile) {
+    await saveGeneratedFile(await processEntryPointConfigAsync(options.entryPointsInputFile), options);
+  }
+
+  // Success
+  process.exit();
+}
+
+async function saveGeneratedFile(saveableType: Class, options: any) {
+  if (options.outputPath) {
+    let outputPath;
     try {
-      outputPath = createPath(appContextFolder, outputPath);
+      outputPath = createPath(saveableType.folderPath, options.outputPath);
     } catch (err) {
-      console.error(`Can't create output folder '${appContextFolder}': ${err.message}`);
+      console.error(`Can't create output folder '${saveableType.folderPath}': ${err.message}`);
       process.exit(ReturnValue.OutputError);
       return;
     }
+
     // Write file
-    const outputFileName = pathUtils.resolve(outputPath, "ClassPathXmlApplicationContext.java");
+    const outputFileName = pathUtils.resolve(outputPath, saveableType.fileName);
     try {
-      await fs.writeFile(outputFileName, output, "utf8");
-      console.log("Output written to %s", outputFileName);
+      await fs.writeFile(outputFileName, saveableType.toString(), "utf8");
+      console.log(`Wrote ${outputFileName}`);
     } catch (err) {
       console.error(`Can't write output file '${outputFileName}': ${err.message}`);
       process.exit(ReturnValue.OutputError);
       return;
     }
-  } else
-    console.log(output);
-  // Success
-  process.exit();
+  } else {
+    console.log(saveableType.toString());
+  }
 }
diff --git a/env-model-generator/src/javaCode.ts b/env-model-generator/src/javaCode.ts
@@ -1,4 +1,5 @@
 import * as _ from "lodash";
+import * as pathUtils from "path";
 
 const maxLineLength = 150;
 
@@ -199,6 +200,24 @@ export class Assignment extends CodeElement implements Statement {
   }
 }
 
+export class Cast extends CodeElement implements Expression {
+    public isExpression: true = true;
+    private castType: string;
+    private expression: Expression;
+
+    public constructor(castType: string, expression: Expression) {
+        super();
+        this.castType = castType;
+        this.expression = expression;
+    }
+
+    public flatten(): string[] {
+        return [
+            `(${this.castType})${this.expression.flatten()}`,
+        ];
+    }
+}
+
 export class Declaration extends CodeElement implements Statement, Member {
   public isStatement: true = true;
   public isMember: true = true;
@@ -498,25 +517,39 @@ export class RangedFor extends CodeElement implements Statement {
 }
 
 export class Class extends CodeElement {
+  private packageName: string;
   private modifiers: string;
   private name: string;
   private baseClass: string | undefined;
   private interfaces: string[];
   private members: Member[];
   private annotations: string[];
+  protected classType: "class" | "interface" | "@interface";
 
   public constructor(
-    modifiers: string, name: string, baseClass: string | undefined, interfaces: string[], members: Member[], annotations?: string[])
+    packageName: string,
+    modifiers: string,
+    name: string,
+    baseClass: string | undefined,
+    interfaces: string[],
+    members: Member[],
+    annotations?: string[])
   {
     super();
+    this.packageName = packageName;
     this.modifiers = modifiers;
     this.name = name;
     this.baseClass = baseClass;
     this.interfaces = interfaces;
     this.members = members;
     this.annotations = annotations === undefined ? [] : annotations;
+    this.classType = "class";
   }
 
+  public get folderPath() { return pathUtils.join(...this.packageName.split(".")); }
+
+  public get fileName() { return this.name + ".java"; }
+
   public flatten(): string[] {
     const members = _.flatMap(this.members, (value, index, array) =>
       index !== array.length - 1 && !(value instanceof BlankLine)
@@ -525,9 +558,39 @@ export class Class extends CodeElement {
     const interfacesString = this.interfaces.length === 0 ? "" : ` implements ${this.interfaces.join(", ")}`;
     return [
       ...this.annotations.map((annotation) => "@" + annotation),
-      `${this.modifiers} class ${this.name}${baseClassString}${interfacesString} {`,
+      `${this.modifiers} ${this.classType} ${this.name}${baseClassString}${interfacesString} {`,
       ..._.flatMap(members, (member) => member.flatten()).map(indent),
       "}",
     ];
   }
+
+  public toString() { return `package ${this.packageName};\n\n` + super.toString() + "\n"; }
+}
+
+export class Interface extends Class {
+  public constructor(
+    packageName: string,
+    modifiers: string,
+    name: string,
+    baseClass: string | undefined,
+    members?: Member[],
+    annotations?: string[])
+  {
+    super(packageName, modifiers, name, baseClass, [], members ? members : [], annotations);
+    this.classType = "interface";
+  }
+}
+
+export class AnnotationInterface extends Class {
+  public constructor(
+    packageName: string,
+    modifiers: string,
+    name: string,
+    baseClass?: string | undefined,
+    members?: Member[],
+    annotations?: string[])
+  {
+    super(packageName, modifiers, name, baseClass, [], members ? members : [], annotations);
+    this.classType = "@interface";
+  }
 }
diff --git a/env-model-generator/src/model.ts b/env-model-generator/src/model.ts
@@ -179,7 +179,7 @@ export class Bean implements IBean {
     }
     if (this.isLazyInit) {
       this._javaMembers.push(new Method(
-        `public static ${typeName} ${this.getter}()`,
+        `public ${typeName} ${this.getter}()`,
         [
           new Declaration(typeName, variableName, new FnCall(creatorFn, constructorArgs)),
           ...initialisers,
@@ -190,7 +190,7 @@ export class Bean implements IBean {
       // Bean is singleton, generate static member variable to hold singleton instance
       this._javaMembers.push(new Declaration(`private static ${typeName}`, variableName));
       this._javaMembers.push(new Method(
-        `public static ${typeName} ${this.getter}()`,
+        `public ${typeName} ${this.getter}()`,
         [
           new IfThenElse(
             new BinaryOperator(new Symbol(variableName), "==", new Null()),
@@ -238,9 +238,9 @@ export class UndefinedBean implements IBean {
   public get javaMembers(): Member[] {
     return [
       new Method(
-        `public static ${this.typeName} ${this.getter}()`,
+        `public ${this.typeName} ${this.getter}()`,
         [
-          new Return(new FnCall("org.cprover.CProver.nondetWithNull", [])),
+          new Return(new FnCall("org.cprover.CProver.nondetWithNull", [new Null()])),
         ],
         []),
         new BlankLine(),
@@ -275,7 +275,7 @@ export class ApplicationContextBean implements IBean {
   public get javaMembers(): Member[] {
     return [
       new Method(
-        `public static ${ApplicationContextBean.typeName} ${this.getter}()`,
+        `public ${ApplicationContextBean.typeName} ${this.getter}()`,
         [
           new Return(new Symbol("this")),
         ],
diff --git a/env-model-generator/src/parserDriver.ts b/env-model-generator/src/parserDriver.ts
