More test samples for dominators

src/bin/cli.ts

@@ -83,7 +83,7 @@ async function main() {
             "--download-compilers <compilerKind...>",
             `Download specified kind of supported compilers to compiler cache. Supports multiple entries.`
         )
-        .option("--run-detectors", "Run defined detecotrs")
+        .option("--run-detectors", "Run defined detectors")
         .option("--dump", "Dump generated DL")
         .option(
             "--dump-analyses <analysisName...>",
@@ -286,15 +286,17 @@ async function main() {
     const units = reader.read(result.data);
     const infer = new InferType(compilerVersion);
 
-    const datalog = buildDatalog(units, infer);
-
     if (options.dump) {
+        const datalog = buildDatalog(units, infer);
+
         console.log(datalog);
+
         return;
     }
 
     if (options.runDetectors) {
         const issues = await detect(units, reader.context, infer);
+
         console.log(issues);
 
         return;
@@ -308,13 +310,15 @@ async function main() {
             options.dumpAnalyses
         )) as SouffleCSVInstance;
         const output = instance.results();
+
         instance.release();
 
         for (const analysis of options.dumpAnalyses) {
             const facts = output.get(analysis);
 
             console.log(analysis, facts ? facts.map((f) => f.toCSVRow()) : facts);
         }
+
         return;
     }
 }

src/lib/detector.ts

@@ -30,7 +30,7 @@ export interface Issue {
 }
 
 function loadDetectorTemplate(jsonPath: string): DetectorTemplate {
-    return fse.readJSONSync(jsonPath) as DetectorTemplate;
+    return fse.readJSONSync(jsonPath);
 }
 
 export function loadDetectors(): DetectorTemplate[] {
@@ -135,10 +135,12 @@ function fmt(template: string, subst: SubstMap, ctx: sol.ASTContext): string {
             const fieldVal = getField(node, field);
 
             template = template.replace(fmtHoleRx, sol.pp(fieldVal));
+
             continue;
         }
 
         m1 = pattern.match(fmtId);
+
         if (m1 !== null) {
             const argName = m1[1];
             const val = subst.get(argName);
@@ -147,6 +149,7 @@ function fmt(template: string, subst: SubstMap, ctx: sol.ASTContext): string {
 
             sol.assert(!(typeof val === "object"), ``);
             template = template.replace(fmtHoleRx, sol.pp(val));
+
             continue;
         }
 
@@ -169,11 +172,14 @@ export function getIssues(output: OutputRelations, ctx: sol.ASTContext): Issue[]
 
     // Parse results
     for (const [name, facts] of output) {
-        if (!detectorMap.has(name)) {
+        const entry = detectorMap.get(name);
+
+        if (entry === undefined) {
             continue;
         }
 
-        const [args, template] = detectorMap.get(name) as [SignatureArgs, DetectorTemplate];
+        const [args, template] = entry;
+
         for (const relnVals of facts) {
             const subst = makeSubst(args, relnVals);
 

src/lib/souffle/instance.ts

@@ -63,6 +63,7 @@ export abstract class SouffleInstance {
 
     async run(outputRelations: string[]): Promise<void> {
         const sysTmpDir = os.tmpdir();
+
         this.tmpDir = await fse.mkdtempSync(join(sysTmpDir, "sol-datalog-"));
 
         this.inputFile = join(this.tmpDir, "input.dl");
@@ -103,6 +104,7 @@ export abstract class SouffleInstance {
 
     release(): void {
         fse.removeSync(this.inputFile);
+
         for (const f of this.outputFiles) {
             fse.removeSync(f);
         }
@@ -130,6 +132,7 @@ export class BaseSouffleCSVInstance extends SouffleInstance {
 
     results(): OutputRelations {
         sol.assert(this.success, `Instance not run yet`);
+
         if (!this._results) {
             this._results = this.readProducedCsvFiles();
         }
@@ -311,6 +314,7 @@ export class SouffleSQLiteInstance extends SouffleInstance implements SouffleSQL
 
     async relationFacts(name: string): Promise<Fact[]> {
         const r = this._relations.get(name);
+
         sol.assert(r !== undefined, `Uknown relation ${name}`);
 
         const rawRes = await this.db.all(`SELECT * from ${name}`);

src/lib/souffle/souffle.ts

@@ -59,6 +59,7 @@ export async function analyze(
             : new SouffleSQLiteInstance(datalog, soDir);
 
     await instance.run(outputRelations);
+
     return instance;
 }
 
@@ -77,6 +78,7 @@ export async function detect(
 
     const instance = (await analyze(units, infer, "csv", outputRelations)) as SouffleCSVInstance;
     const outputs = instance.results();
+
     instance.release();
 
     const res = getIssues(outputs, context);

test/analyses.spec.ts

@@ -19,29 +19,26 @@ describe("Analyses", () => {
         describe(sample, () => {
             let units: sol.SourceUnit[];
             let expectedOutput: OutputRelations;
-            let reader: sol.ASTReader;
             let version: string;
 
             before(async () => {
-                reader = new sol.ASTReader();
                 const result = await sol.compileSol(sample, "auto");
 
                 const data = result.data;
                 const errors = sol.detectCompileErrors(data);
 
                 expect(errors).toHaveLength(0);
+
                 version = result.compilerVersion as string;
 
-                units = reader.read(data);
+                units = new sol.ASTReader().read(data);
 
                 expect(units.length).toBeGreaterThanOrEqual(1);
 
-                expectedOutput = fse.readJSONSync(json, {
-                    encoding: "utf-8"
-                }) as OutputRelations;
+                expectedOutput = fse.readJSONSync(json, { encoding: "utf-8" });
             });
 
-            it("Detectors produce expected results", async () => {
+            it("Analyses produce expected results", async () => {
                 const targetAnalyses = [...Object.keys(expectedOutput)];
                 const infer = new sol.InferType(version);
                 const instance = (await analyze(
@@ -51,9 +48,16 @@ describe("Analyses", () => {
                     targetAnalyses,
                     DIST_SO_DIR
                 )) as SouffleCSVInstance;
+
                 const analysisResults = instance.results();
+
                 instance.release();
 
+                // await fse.writeFile(
+                //     json,
+                //     JSON.stringify(Object.fromEntries(analysisResults.entries()), undefined, 4)
+                // );
+
                 for (const [key, val] of Object.entries(expectedOutput)) {
                     expect(
                         (analysisResults.get(key) as Fact[]).map((fact) => fact.toJSON())
@@ -71,11 +75,9 @@ describe("Analyses work in sqlite mode", () => {
     describe(sample, () => {
         let units: sol.SourceUnit[];
         let expectedOutput: OutputRelations;
-        let reader: sol.ASTReader;
         let version: string;
 
         before(async () => {
-            reader = new sol.ASTReader();
             const result = await sol.compileSol(sample, "auto");
 
             const data = result.data;
@@ -84,7 +86,7 @@ describe("Analyses work in sqlite mode", () => {
             expect(errors).toHaveLength(0);
 
             version = result.compilerVersion as string;
-            units = reader.read(data);
+            units = new sol.ASTReader().read(data);
 
             expect(units.length).toBeGreaterThanOrEqual(1);
 
@@ -93,7 +95,7 @@ describe("Analyses work in sqlite mode", () => {
             }) as OutputRelations;
         });
 
-        it("Detectors produce expected results", async () => {
+        it("Analyses produce expected results", async () => {
             const targetAnalyses = [...Object.keys(expectedOutput)];
             const infer = new sol.InferType(version);
             const instance = (await analyze(
@@ -105,6 +107,7 @@ describe("Analyses work in sqlite mode", () => {
 
             for (const [key, val] of Object.entries(expectedOutput)) {
                 const actualResutls = (await instance.relationFacts(key)).map((f) => f.fields);
+
                 expect(actualResutls).toEqual(val);
             }
 

test/detectors.spec.ts

@@ -11,32 +11,35 @@ describe("Detectors", () => {
         describe(sample, () => {
             let units: sol.SourceUnit[];
             let expectedIssues: Issue[];
-            let reader: sol.ASTReader;
+            let ctx: sol.ASTContext;
             let version: string;
 
             before(async () => {
-                reader = new sol.ASTReader();
                 const result = await sol.compileSol(sample, "auto");
 
                 const data = result.data;
                 const errors = sol.detectCompileErrors(data);
 
                 expect(errors).toHaveLength(0);
 
+                const reader = new sol.ASTReader();
+
                 version = result.compilerVersion as string;
 
                 units = reader.read(data);
+                ctx = reader.context;
 
                 expect(units.length).toBeGreaterThanOrEqual(1);
 
                 expectedIssues = fse.readJSONSync(sample.replace(".sol", ".json"), {
                     encoding: "utf-8"
-                }) as Issue[];
+                });
             });
 
             it("Detectors produce expected results", async () => {
                 const infer = new sol.InferType(version);
-                const actualIssues = await detect(units, reader.context, infer);
+                const actualIssues = await detect(units, ctx, infer);
+
                 expect(actualIssues).toEqual(expectedIssues);
             });
         });