occam-verify-cli 1.0.318 → 1.0.325

package/lib/verifier/constructor.js

@@ -211,12 +211,12 @@ _define_property(ConstructorVerifier, "maps", [
         nodeQuery: typeNodeQuery,
         verify: function(typeNode, context, verifyAhead) {
             var typeVerifies;
-            var typeName = typeNode.getTypeName(), typePresent = context.isTypePresentByTypeName(typeName);
+            var nominalTypeName = typeNode.getNominalTypeName(), typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
             if (typePresent) {
                 var verifiesAhead = verifyAhead();
                 typeVerifies = verifiesAhead; ///
             } else {
-                var typeString = typeName; ///
+                var typeString = nominalTypeName; ///
                 context.debug("The '".concat(typeString, "' type is not present."));
                 typeVerifies = false;
             }
@@ -227,4 +227,4 @@ _define_property(ConstructorVerifier, "maps", [
 var constructorVerifier = new ConstructorVerifier();
 var _default = constructorVerifier;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.318",
+  "version": "1.0.325",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/context/file.js

@@ -33,7 +33,7 @@ import { typesFromJSON,
          metatheoremsToMetatheoremsJSON,
          metavariablesToMetavariablesJSON } from "../utilities/json";
 
-const { push, first, filter } = arrayUtilities;
+const { push, filter } = arrayUtilities;
 
 export default class FileContext {
   constructor(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables) {
@@ -83,6 +83,8 @@ export default class FileContext {
 
   getMetaTypes() { return this.releaseContext.getMetaTypes(); }
 
+  getTypePrefix() { return this.releaseContext.getTypePrefix(); }
+
   getJudgements() {
     const judgements = [];
 
@@ -104,117 +106,87 @@ export default class FileContext {
   getLabels(includeRelease = true) {
     const labels = [];
 
-    this.rules.forEach((rule) => {
-      const ruleLabels = rule.getLabels();
+    if (includeRelease) {
+      const releaseContextLabels = this.releaseContext.getLabels();
 
-      push(labels, ruleLabels);
-    });
+      push(labels, releaseContextLabels);
+    } else {
+      this.rules.forEach((rule) => {
+        const ruleLabels = rule.getLabels();
 
-    this.axioms.forEach((axiom) => {
-      const axiomLabels = axiom.getLabels();
+        push(labels, ruleLabels);
+      });
 
-      push(labels, axiomLabels);
-    });
+      this.axioms.forEach((axiom) => {
+        const axiomLabels = axiom.getLabels();
 
-    this.lemmas.forEach((lemma) => {
-      const lemmaLabels = lemma.getLabels();
+        push(labels, axiomLabels);
+      });
 
-      push(labels, lemmaLabels);
-    });
+      this.lemmas.forEach((lemma) => {
+        const lemmaLabels = lemma.getLabels();
 
-    this.theorems.forEach((theorem) => {
-      const theoremLabels = theorem.getLabels();
+        push(labels, lemmaLabels);
+      });
 
-      push(labels, theoremLabels);
-    });
+      this.theorems.forEach((theorem) => {
+        const theoremLabels = theorem.getLabels();
 
-    this.conjectures.forEach((conjecture) => {
-      const conjectureLabels = conjecture.getLabels();
+        push(labels, theoremLabels);
+      });
 
-      push(labels, conjectureLabels);
-    });
+      this.conjectures.forEach((conjecture) => {
+        const conjectureLabels = conjecture.getLabels();
 
-    this.metatheorems.forEach((metatheorem) => {
-      const metatheoremLabel = metatheorem.getLabel();
+        push(labels, conjectureLabels);
+      });
 
-      labels.push(metatheoremLabel);
-    });
+      this.metatheorems.forEach((metatheorem) => {
+        const metatheoremLabel = metatheorem.getLabel();
 
-    if (includeRelease) {
-      const releaseContextLabels = this.releaseContext.getLabels();
-
-      push(labels, releaseContextLabels);
+        labels.push(metatheoremLabel);
+      });
     }
 
     return labels;
   }
 
-  getTypes(includeRelease = true) {
-    const types = [];
-
-    push(types, this.types);
-
-    if (includeRelease) {
-      const releaseContextTypes = this.releaseContext.getTypes();
-
-      push(types, releaseContextTypes);
-    }
+  getTypes(includeRelease = true, includeDependencies = true) {
+    const types = includeRelease ?
+                    this.releaseContext.getTypes(includeDependencies) :
+                      this.types;
 
     return types;
   }
 
   getRules(includeRelease = true) {
-    const rules = []
-
-    push(rules, this.rules);
-
-    if (includeRelease) {
-      const releaseContextRules = this.releaseContext.getRules();
-
-      push(rules, releaseContextRules);
-    }
+    const rules = includeRelease ?
+                    this.releaseContext.getRules() :
+                      this.rules;
 
     return rules;
   }
 
   getAxioms(includeRelease = true) {
-    const axioms = [];
-
-    push(axioms, this.axioms);
-
-    if (includeRelease) {
-      const releaseContextAxioms = this.releaseContext.getAxioms();
-
-      push(axioms, releaseContextAxioms);
-    }
+    const axioms = includeRelease ?
+                     this.releaseContext.getAxioms() :
+                       this.axioms;
 
     return axioms;
   }
 
   getLemmas(includeRelease = true) {
-    const lemmas = [];
-
-    push(lemmas, this.lemmas);
-
-    if (includeRelease) {
-      const releaseContextLemmas = this.releaseContext.getLemmas();
-
-      push(lemmas, releaseContextLemmas);
-    }
+    const lemmas = includeRelease ?
+                     this.releaseContext.getLemmas() :
+                       this.lemmas;
 
     return lemmas;
   }
 
   getTheorems(includeRelease = true) {
-    const theorems = [];
-
-    push(theorems, this.theorems);
-
-    if (includeRelease) {
-      const releaseContextTheorems = this.releaseContext.getTheorems();
-
-      push(theorems, releaseContextTheorems);
-    }
+    const theorems = includeRelease ?
+                       this.releaseContext.getTheorems() :
+                         this.theorems;
 
     return theorems;
   }
@@ -224,97 +196,57 @@ export default class FileContext {
   }
 
   getProcedures(includeRelease = true) {
-    const procedures = [];
-
-    if (includeRelease) {
-      const releaseContextProcedures = this.releaseContext.getProcedures();
-
-      push(procedures, releaseContextProcedures);
-    }
+    const procedures = includeRelease ?
+                         this.releaseContext.getProcedures() :
+                           null;  ///
 
     return procedures;
   }
 
   getMetaLemmas(includeRelease = true) {
-    const metaLemmas = [];
-
-    push(metaLemmas, this.metaLemmas);
-
-    if (includeRelease) {
-      const releaseContextMetaLemmas = this.releaseContext.getMetaLemmas();
-
-      push(metaLemmas, releaseContextMetaLemmas);
-    }
+    const metaLemmas = includeRelease ?
+                         this.releaseContext.getMetaLemmas() :
+                           this.metaLemmas;
 
     return metaLemmas;
   }
 
   getConjectures(includeRelease = true) {
-    const conjectures = [];
-
-    push(conjectures, this.conjectures);
-
-    if (includeRelease) {
-      const releaseContextConjectures = this.releaseContext.getConjectures();
-
-      push(conjectures, releaseContextConjectures);
-    }
+    const conjectures = includeRelease ?
+                          this.releaseContext.getConjectures() :
+                            this.conjectures;
 
     return conjectures;
   }
 
   getCombinators(includeRelease = true) {
-    const combinators = [];
-
-    push(combinators, this.combinators);
-
-    if (includeRelease) {
-      const releaseContextCombinators = this.releaseContext.getCombinators();
-
-      push(combinators, releaseContextCombinators);
-    }
+    const combinators = includeRelease ?
+                          this.releaseContext.getCombinators() :
+                            this.combinators;
 
     return combinators;
   }
 
   getTypePrefixes(includeRelease = true) {
-    const typePrefixes = [];
-
-    push(typePrefixes, this.typePrefixes);
-
-    if (includeRelease) {
-      const releaseContextTypePrefixes = this.releaseContext.getTypePrefixes();
-
-      push(typePrefixes, releaseContextTypePrefixes);
-    }
+    const typePrefixes = includeRelease ?
+                           this.releaseContext.getTypePrefixes() :
+                             this.typePrefixes;
 
     return typePrefixes;
   }
 
   getConstructors(includeRelease = true) {
-    const constructors = [];
-
-    push(constructors, this.constructors);
-
-    if (includeRelease) {
-      const releaseContextConstructors = this.releaseContext.getConstructors();
-
-      push(constructors, releaseContextConstructors);
-    }
+    const constructors = includeRelease ?
+                           this.releaseContext.getConstructors() :
+                             this.constructors;
 
     return constructors;
   }
 
   getMetatheorems(includeRelease = true) {
-    const metatheorems = [];
-
-    push(metatheorems, this.metatheorems);
-
-    if (includeRelease) {
-      const releaseContextMetatheorems = this.releaseContext.getMetatheorems();
-
-      push(metatheorems, releaseContextMetatheorems);
-    }
+    const metatheorems = includeRelease ?
+                           this.releaseContext.getMetatheorems() :
+                             this.metatheorems;
 
     return metatheorems;
   }
@@ -329,28 +261,6 @@ export default class FileContext {
     return fileContext;
   }
 
-  getTypePrefix(includeRelease = true) {
-    let typePrefix = null;
-
-    if (typePrefix === null) {
-      const typePrefixesLength = this.typePrefixes.length;
-
-      if (typePrefixesLength === 1) {
-        const firstTypePrefix = first(this.typePrefixes);
-
-        typePrefix = firstTypePrefix; ///
-      }
-    }
-
-    if (typePrefix === null) {
-      if (includeRelease) {
-        typePrefix = this.releaseContext.getTypePrefix();
-      }
-    }
-
-    return typePrefix;
-  }
-
   addType(type) {
     this.types.push(type);
   }
@@ -387,6 +297,10 @@ export default class FileContext {
     this.combinators.push(combinator);
   }
 
+  addTypePrefix(typePrefix) {
+    this.typePrefixes.push(typePrefix);
+  }
+
   addConstructor(constructor) {
     this.constructors.push(constructor);
   }
@@ -602,8 +516,8 @@ export default class FileContext {
     return metavariable;
   }
 
-  findTypeByTypeName(typeName) {
-    let types = this.getTypes();
+  findTypeByTypeName(typeName, includeRelease = true, includeDependencies = true) {
+    let types = this.getTypes(includeRelease, includeDependencies);
 
     types = [
       ...types,
@@ -621,17 +535,42 @@ export default class FileContext {
     return type;
   }
 
-  findTypePrefixByTypePrefixName(typePrefixName) {
-    const typePrefixes = this.getTypePrefixes(),
-          typePrefix = typePrefixes.find((typePrefix) => {
-            const typePrefixNameMatches = typePrefix.matchTypePrefixName(typePrefixName);
+  findTypeByNominalTypeName(nominalTypeName) {
+    let types = this.getTypes();
 
-            if (typePrefixNameMatches) {
-              return true;
-            }
-          }) || null;
+    types = [
+      ...types,
+      objectType
+    ];
 
-    return typePrefix;
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchNominalTypeName(nominalTypeName);
+
+      if (typeNameMatches) {
+        return true;
+      }
+    }) || null;
+
+    return type;
+  }
+
+  findTypeByPrefixedTypeName(prefixedTypeName) {
+    let types = this.getTypes();
+
+    types = [
+      ...types,
+      objectType
+    ];
+
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchPrefixedTypeName(prefixedTypeName);
+
+      if (typeNameMatches) {
+        return true;
+      }
+    }) || null;
+
+    return type;
   }
 
   findMetaTypeByMetaTypeName(metaTypeName) {
@@ -647,6 +586,19 @@ export default class FileContext {
     return metaType;
   }
 
+  findTypePrefixByTypePrefixName(typePrefixName) {
+    const typePrefixes = this.getTypePrefixes(),
+          typePrefix = typePrefixes.find((typePrefix) => {
+            const typePrefixNameMatches = typePrefix.matchTypePrefixName(typePrefixName);
+
+            if (typePrefixNameMatches) {
+              return true;
+            }
+          }) || null;
+
+    return typePrefix;
+  }
+
   findVariableByVariableIdentifier(variableIdentifier) {
     const variables = this.getVariables(),
           variable = variables.find((variable) => {
@@ -725,8 +677,22 @@ export default class FileContext {
     return metavariablePresent;
   }
 
-  isTypePresentByTypeName(typeName) {
-    const type = this.findTypeByTypeName(typeName),
+  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) {
+    const type = this.findTypeByTypeName(typeName, includeRelease, includeDependencies),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
+  isTypePresentByNominalTypeName(nominalTypeName) {
+    const type = this.findTypeByNominalTypeName(nominalTypeName),
+          typePresent = (type !== null);
+
+    return typePresent;
+  }
+
+  isTypePresentByPrefixedTypeName(prefixedTypeName) {
+    const type = this.findTypeByPrefixedTypeName(prefixedTypeName),
           typePresent = (type !== null);
 
     return typePresent;

package/src/context/local.js

@@ -231,10 +231,10 @@ class LocalContext {
 
   findMetavariable(metavariable, generalContext, specificContext) { return this.context.findMetavariable(metavariable, generalContext, specificContext); }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
   findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
 
+  findTypeByNominalTypeName(nominalTypeName) { return this.context.findTypeByNominalTypeName(nominalTypeName); }
+
   findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
 
   findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
@@ -251,7 +251,11 @@ class LocalContext {
 
   isMetavariablePresent(metavariable, generalContext, specificContext) { return this.context.isMetavariablePresent(metavariable, generalContext, specificContext); }
 
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+  isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
+
+  isTypePresentByNominalTypeName(nominalTypeName) { return this.context.isTypePresentByNominalTypeName(nominalTypeName); }
+
+  isTypePresentByPrefixedTypeName(prefixedTypeName) { return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName); }
 
   isTypePrefixPresentByTypePrefixName(typePrefixName) { return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName); }
 

package/src/context/release.js

@@ -13,9 +13,9 @@ import NominalParser from "../nominal/parser";
 import { frameMetaType, referenceMetaType, statementMetaType } from "../dom/metaType";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
-const { tail, push, first, clear, resolve } = arrayUtilities,
-      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
+      { tail, push, first, clear, filter, resolve, compress } = arrayUtilities,
       { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities;
 
 export default class ReleaseContext {
@@ -469,15 +469,21 @@ export default class ReleaseContext {
   verify() {
     let verifies = false;
 
-    const verifiedFileContexts = [],
-          fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts);
+    const typePrefixes = this.getTypePrefixes(),
+          releaseContext = this, ///
+          typePrefixesVerify = verifyTypePrefixes(typePrefixes, releaseContext);
 
-    if (fileContextsVerify) {
-      this.fileContexts = verifiedFileContexts; ///
+    if (typePrefixesVerify) {
+      const verifiedFileContexts = [],
+            fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts, releaseContext);
 
-      this.verified = true;
+      if (fileContextsVerify) {
+        this.fileContexts = verifiedFileContexts; ///
 
-      verifies = true;
+        this.verified = true;
+
+        verifies = true;
+      }
     }
 
     return verifies;
@@ -508,6 +514,46 @@ export default class ReleaseContext {
   }
 }
 
+function verifyTypePrefixes(typePrefixes, releaseContext) {
+  let typePrefixesVerify = true;
+
+  const typePrefixesLength = typePrefixes.length,
+        compressedTypePrefixes = [  ///
+          ...typePrefixes,
+        ];
+
+  compress(compressedTypePrefixes, (typePrefixA, typePrefixB) => {
+    const typePrefixAName = typePrefixA.getName(),
+          typePrefixBName = typePrefixB.getName();
+
+    if (typePrefixAName === typePrefixBName) {
+      return true;
+    }
+  });
+
+  const compressTypePrefixesLength = compressedTypePrefixes.length;
+
+  if (typePrefixesLength > compressTypePrefixesLength) {
+    filter(compressedTypePrefixes, (typePrefix) => {
+      const typePrefixesIncludesTypePrefix = typePrefixes.includes(typePrefix);
+
+      if (!typePrefixesIncludesTypePrefix) {
+        return true;
+      }
+    });
+
+    const firstTypePrefix = first(typePrefixes),
+          typePrefix = firstTypePrefix, ///
+          typePrefixString = typePrefix.getString();
+
+    releaseContext.info(`The '${typePrefixString}' type prefix is duplicated at least once, possibly among others.`)
+
+    typePrefixesVerify = false;
+  }
+
+  return typePrefixesVerify;
+}
+
 function verifyFileContexts(fileContexts, verifiedFileContexts) {
   const resolved = resolve(fileContexts, verifiedFileContexts, (fileContext) => {
           const fileContextVerifies = fileContext.verify();

package/src/dom/assertion/type.js

@@ -64,12 +64,12 @@ export default domAssigned(class TypeAssertion {
   verifyType(context) {
     let typeVerifies;
 
-    const typeName = this.type.getName(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' type...`);
 
-    const type = context.findTypeByTypeName(typeName);
+    const nominalTypeName = this.type.getNominalTypeName(),
+          type = context.findTypeByNominalTypeName(nominalTypeName);
 
     if (type !== null) {
       this.type = type;