occam-verify-cli 1.0.320 → 1.0.326

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) {
@@ -106,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);
-    });
-
-    if (includeRelease) {
-      const releaseContextLabels = this.releaseContext.getLabels();
+      this.metatheorems.forEach((metatheorem) => {
+        const metatheoremLabel = metatheorem.getLabel();
 
-      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;
   }
@@ -226,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;
   }
@@ -586,7 +516,26 @@ export default class FileContext {
     return metavariable;
   }
 
-  findTypeByTypeName(typeName, prefixed = true) {
+  findTypeByTypeName(typeName, includeRelease = true, includeDependencies = true) {
+    let types = this.getTypes(includeRelease, includeDependencies);
+
+    types = [
+      ...types,
+      objectType
+    ];
+
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchTypeName(typeName);
+
+      if (typeNameMatches) {
+        return true;
+      }
+    }) || null;
+
+    return type;
+  }
+
+  findTypeByNominalTypeName(nominalTypeName) {
     let types = this.getTypes();
 
     types = [
@@ -594,29 +543,34 @@ export default class FileContext {
       objectType
     ];
 
-    const context = this, ///
-          type = types.find((type) => {
-            const typeNameMatches = type.matchTypeName(typeName, prefixed, context);
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchNominalTypeName(nominalTypeName);
 
-            if (typeNameMatches) {
-              return true;
-            }
-          }) || null;
+      if (typeNameMatches) {
+        return true;
+      }
+    }) || null;
 
     return type;
   }
 
-  findTypePrefixByTypePrefixName(typePrefixName) {
-    const typePrefixes = this.getTypePrefixes(),
-          typePrefix = typePrefixes.find((typePrefix) => {
-            const typePrefixNameMatches = typePrefix.matchTypePrefixName(typePrefixName);
+  findTypeByPrefixedTypeName(prefixedTypeName) {
+    let types = this.getTypes();
 
-            if (typePrefixNameMatches) {
-              return true;
-            }
-          }) || null;
+    types = [
+      ...types,
+      objectType
+    ];
 
-    return typePrefix;
+    const type = types.find((type) => {
+      const typeNameMatches = type.matchPrefixedTypeName(prefixedTypeName);
+
+      if (typeNameMatches) {
+        return true;
+      }
+    }) || null;
+
+    return type;
   }
 
   findMetaTypeByMetaTypeName(metaTypeName) {
@@ -632,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) => {
@@ -710,8 +677,22 @@ export default class FileContext {
     return metavariablePresent;
   }
 
-  isTypePresentByTypeName(typeName, prefixed = true) {
-    const type = this.findTypeByTypeName(typeName, prefixed),
+  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, prefixed = true) { return this.context.isTypePresentByTypeName(typeName, prefixed); }
+  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;