Merge pull request diffblue#521 from diffblue/feature/DI-fallback

Create nondet initialisation for unresolved bean types [SEC-584]

Author: NathanJPhillips

env-model-generator/src/env-model-generator.ts

@@ -67,15 +67,17 @@ async function transformConfigFiles(fileName: string, options: any) {
               new Block(
                 "try",
                 (<Statement[]>[]).concat(
-                  model.Bean.getNamed().map((bean) =>
-                    new Block(
-                      `if (name.equals("${bean.name}"))`,
-                      [
-                        new Return(new FnCall(bean.getter, [])),
-                      ])),
-                  [...model.Bean.getAliases()].map(
+                  model.Repository.getNamed()
+                    .sort((a, b) => a.name < b.name ? -1 : a.name === b.name ? 0 : 1)
+                    .map((bean) =>
+                      new Block(
+                        `if (name.equals("${bean.name}"))`,
+                        [
+                          new Return(new FnCall(bean.getter, [])),
+                        ])),
+                  [...model.Repository.getAliases()].map(
                     function ([ alias, beanId ]) {
-                      const bean = model.Bean.tryGet(beanId);
+                      const bean = model.Repository.tryGet(beanId);
                       if (bean === undefined)
                         throw new Error("Found alias to bean that doesn't exist");
                       return new Block(
@@ -96,7 +98,7 @@ async function transformConfigFiles(fileName: string, options: any) {
           ),
           new BlankLine(),
           new BlankLine(),
-          ..._.flatMap([...model.Bean.getAll()], (bean) => bean.javaMembers),
+          ..._.flatMap([...model.Repository.getAll()], (bean) => bean.javaMembers),
           new BlankLine(),
           ...model.PropertiesValue.utilityMethods(),
           ...model.MapValue.utilityMethods(),

env-model-generator/src/model.ts

@@ -26,12 +26,20 @@ export interface BeanProperty {
 }
 
 interface Factory {
-  bean: Bean;
+  bean: IBean;
   method: string;
 }
 
-export class Bean {
-  private readonly isAnonymous: boolean;
+export interface IBean {
+  readonly IsAnonymous: boolean;
+  readonly name: string;
+  readonly getter: string;
+  readonly javaMembers: Member[];
+  readonly exceptions: string[];
+}
+
+export class Bean implements IBean {
+  public readonly IsAnonymous: boolean;
   public readonly name: string;
   private readonly impl: string | Factory;
   private readonly isLazyInit: boolean;
@@ -70,16 +78,16 @@ export class Bean {
 
     if (impl === undefined)
       throw Error(`Tried to create a Bean ('${name}') without a class name or a factory bean/method`);
-    this.isAnonymous = name === undefined;
+    this.IsAnonymous = name === undefined;
     if (name === undefined)
-      name = Bean.getNextAnonName(typeof impl === "string" ? impl : impl.bean.identifier + "_" + impl.method);
+      name = Bean.getNextAnonName(typeof impl === "string" ? impl : impl.bean.name + "_" + impl.method);
     this.name = name;
     this.impl = impl;
     this.isLazyInit = isLazyInit;
     this.constructorArgs = constructorArgs;
     this.properties = propertiesMap;
     this.initMethod = initMethod;
-    Bean.beans.add(this);
+    Repository.registerBean(this);
   }
 
   private get identifier(): string {
@@ -172,46 +180,83 @@ export class Bean {
     Bean.anonIndexByClass.set(baseName, index);
     return baseName + index;
   }
+}
+
+export class UndefinedBean implements IBean {
+  private readonly typeName: string;
+  public readonly name: string;
+  public readonly IsAnonymous = true;
+
+  public constructor(identifier: string, typeName: string) {
+    this.name = identifier;
+    this.typeName = typeName;
+    Repository.registerBean(this);
+    Repository.registerIdForClass(this.typeName, this.name);
+  }
+
+  public get getter(): string {
+    return `get${upperInitialChar(this.name)}`;
+  }
+
+  public get javaMembers(): Member[] {
+    return [
+      new Method(
+        `public static ${this.typeName} ${this.getter}()`,
+        [
+          new Return(new FnCall("org.cprover.CProver.nondetWithNull", [])),
+        ],
+        []),
+        new BlankLine(),
+    ];
+  }
+
+  public readonly exceptions: string[] = [];
+}
 
-  private static beans = new NameMap<Bean>();
+export namespace Repository {
+  const beans = new NameMap<IBean>();
+
+  export function registerBean(bean: IBean) {
+    beans.add(bean);
+  }
 
-  public static tryGet(beanId: string) {
-    const aliasedBeanId = Bean.getAlias(beanId);
-    return Bean.beans.get(aliasedBeanId === undefined ? beanId : aliasedBeanId);
+  export function tryGet(beanId: string) {
+    const aliasedBeanId = getAlias(beanId);
+    return beans.get(aliasedBeanId === undefined ? beanId : aliasedBeanId);
   }
 
-  public static getAll(): Iterable<Bean> {
-    return Bean.beans;
+  export function getAll(): Iterable<IBean> {
+    return beans;
   }
 
-  public static getNamed(): Bean[] {
-    return [...Bean.getAll()].filter((bean) => !bean.isAnonymous);
+  export function getNamed(): IBean[] {
+    return [...getAll()].filter((bean) => !bean.IsAnonymous);
   }
 
-  private static aliases = new Map<string, string>();
+  let aliases = new Map<string, string>();
 
-  public static getAlias(alias: string): string | undefined {
-    return Bean.aliases.get(alias);
+  export function getAlias(alias: string): string | undefined {
+    return aliases.get(alias);
   }
 
-  public static addAlias(alias: string, beanId: string) {
-    const existingAlias = Bean.getAlias(alias);
+  export function addAlias(alias: string, beanId: string) {
+    const existingAlias = getAlias(alias);
     if (existingAlias !== undefined) {
       if (existingAlias !== beanId)
         throw new ConfigParseError(`Found multiple aliases from '${alias}' to '${existingAlias}' and '${beanId}'`);
       // No point in adding the same alias again
       return;
     }
-    Bean.aliases.set(alias, beanId);
+    aliases.set(alias, beanId);
   }
 
-  public static checkAliases(beanWithIdExists: (beanId: string) => boolean): void {
+  export function checkAliases(beanWithIdExists: (beanId: string) => boolean): void {
     // If A -> B is added before B -> C then A -> B needs updating to A -> C now
-    const aliases = new Map<string, string>();
-    for (const [ alias, target ] of Bean.aliases) {
+    const simplifiedAliases = new Map<string, string>();
+    for (const [ alias, target ] of aliases) {
       let beanId = target;
       while (true) {
-        const aliasedBeanId = Bean.aliases.get(beanId);
+        const aliasedBeanId = aliases.get(beanId);
         if (aliasedBeanId === undefined)
           break;
         beanId = aliasedBeanId;
@@ -220,27 +265,27 @@ export class Bean {
       }
       if (!beanWithIdExists(beanId))
         throw new ConfigParseError(`Couldn't find bean '${beanId}' aliased from '${alias}'`);
-      aliases.set(alias, beanId);
+      simplifiedAliases.set(alias, beanId);
     }
-    Bean.aliases = aliases;
+    aliases = simplifiedAliases;
   }
 
-  public static getAliases(): Iterable<[ string, string ]> {
-    return Bean.aliases;
+  export function getAliases(): Iterable<[ string, string ]> {
+    return aliases;
   }
 
-  private static beanIdByClass = new MapTrackingDuplicates<string, string>();
+  const beanIdByClass = new MapTrackingDuplicates<string, string>();
 
-  public static registerIdForClass(qualifiedClassName: string, beanId: string) {
-    Bean.beanIdByClass.set(qualifiedClassName, beanId);
+  export function registerIdForClass(qualifiedClassName: string, beanId: string) {
+    beanIdByClass.set(qualifiedClassName, beanId);
   }
 
-  public static tryGetIdByClass(qualifiedClassName: string): string | undefined {
-    return Bean.beanIdByClass.get(qualifiedClassName);
+  export function tryGetIdByClass(qualifiedClassName: string): string | undefined {
+    return beanIdByClass.get(qualifiedClassName);
   }
 
-  public static hasMultipleBeansForClass(qualifiedClassName: string): boolean {
-    return Bean.beanIdByClass.hasDuplicates(qualifiedClassName);
+  export function hasMultipleBeansForClass(qualifiedClassName: string): boolean {
+    return beanIdByClass.hasDuplicates(qualifiedClassName);
   }
 }
 
@@ -384,7 +429,7 @@ export class BeanRefValue extends Value {
   }
 
   private get bean() {
-    const bean = Bean.tryGet(this.beanRef);
+    const bean = Repository.tryGet(this.beanRef);
     if (bean === undefined)
       throw new Error(`Reference created to bean '${this.beanRef}' that has no implementation`);
     return bean;
@@ -396,9 +441,9 @@ export class BeanRefValue extends Value {
 }
 
 export class BeanValue extends Value {
-  private bean: Bean;
+  private bean: IBean;
 
-  public constructor(bean: Bean) {
+  public constructor(bean: IBean) {
     super();
     this.bean = bean;
   }

env-model-generator/src/nameMap.ts

@@ -13,46 +13,48 @@ export default class NameMap<T extends NamedObject> implements Iterable<T> {
       initialValues === undefined ? undefined : initialValues.map((v) => <[string, T]>[v.name, v]));
   }
 
-  public add(elt: T) {
+  public add(elt: T): this {
     if (this._map.has(elt.name))
       throw new Error(`Tried to add object with same name '${elt.name}' as an object that already exists in this NameMap`);
     return this.set(elt);
   }
 
-  public set(elt: T) {
+  public set(elt: T): this {
     this._map.set(elt.name, elt);
     return this;
   }
 
-  public addRange(values: T[]) {
+  public addRange(values: T[]): this {
     for (const value of values)
       this.add(value);
+    return this;
   }
 
-  public setRange(values: T[]) {
+  public setRange(values: T[]): this {
     for (const value of values)
       this.set(value);
+    return this;
   }
 
-  public has(name: string) {
+  public has(name: string): boolean {
     return this._map.has(name);
   }
 
-  public get(name: string) {
+  public get(name: string): T | undefined {
     return this._map.get(name);
   }
 
-  public delete(name: string) {
+  public delete(name: string): this {
     this._map.delete(name);
     return this;
   }
 
-  public clear() {
+  public clear(): this {
     this._map.clear();
     return this;
   }
 
-  public getOrAdd(name: string, generator: () => T) {
+  public getOrAdd(name: string, generator: () => T): T {
     let elt = this.get(name);
     if (elt !== undefined)
       return elt;
@@ -61,7 +63,7 @@ export default class NameMap<T extends NamedObject> implements Iterable<T> {
     return elt;
   }
 
-  public get size() {
+  public get size(): number {
     return this._map.size;
   }