occam-verify-cli 1.0.315 → 1.0.317

package/src/context/file.js

@@ -19,22 +19,24 @@ import { typesFromJSON,
          axiomsToAxiomsJSON,
          conjecturesFromJSON,
          combinatorsFromJSON,
+         typePrefixesFromJSON,
          constructorsFromJSON,
          metatheoremsFromJSON,
          metavariablesFromJSON,
          metaLemmasFromNothing,
          theoremsToTheoremsJSON,
          variablesToVariablesJSON,
+         typePrefixesToTypePrefixesJSON,
          conjecturesToConjecturesJSON,
          combinatorsToCombinatorsJSON,
          constructorsToConstructorsJSON,
          metatheoremsToMetatheoremsJSON,
          metavariablesToMetavariablesJSON } from "../utilities/json";
 
-const { push, filter } = arrayUtilities;
+const { push, first, filter } = arrayUtilities;
 
 export default class FileContext {
-  constructor(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables) {
+  constructor(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.lineIndex = lineIndex;
@@ -49,6 +51,7 @@ export default class FileContext {
     this.metaLemmas = metaLemmas;
     this.conjectures = conjectures;
     this.combinators = combinators;
+    this.typePrefixes = typePrefixes;
     this.constructors = constructors;
     this.metatheorems = metatheorems;
     this.metavariables = metavariables;
@@ -274,6 +277,10 @@ export default class FileContext {
     return combinators;
   }
 
+  getTypePrefixes(includeRelease = true) {
+    return this.typePrefixes;
+  }
+
   getConstructors(includeRelease = true) {
     const constructors = [];
 
@@ -312,6 +319,20 @@ export default class FileContext {
     return fileContext;
   }
 
+  getTypePrefix() {
+    let typePrefix = null;
+
+    const typePrefixesLength = this.typePrefixes.length;
+
+    if (typePrefixesLength === 1) {
+      const firstTypePrefix = first(this.typePrefixes);
+
+      typePrefix = firstTypePrefix; ///
+    }
+
+    return typePrefix;
+  }
+
   addType(type) {
     this.types.push(type);
   }
@@ -862,6 +883,7 @@ export default class FileContext {
     this.metaLemmas = [];
     this.conjectures = [];
     this.combinators = [];
+    this.typePrefixes = [];
     this.constructors = [];
     this.metatheorems = [];
     this.metavariables = [];
@@ -907,6 +929,8 @@ export default class FileContext {
 
     this.combinators = combinatorsFromJSON(json, fileContext);
 
+    this.typePrefixes = typePrefixesFromJSON(json, fileContext);
+
     this.constructors = constructorsFromJSON(json, fileContext);
 
     this.metatheorems = metatheoremsFromJSON(json, fileContext);
@@ -922,6 +946,7 @@ export default class FileContext {
           variablesJSON = variablesToVariablesJSON(this.variables),
           conjecturesJSON = conjecturesToConjecturesJSON(this.conjectures),
           combinatorsJSON = combinatorsToCombinatorsJSON(this.combinators),
+          typePrefixesJSON = typePrefixesToTypePrefixesJSON(this.typePrefixes),
           constructorsJSON = constructorsToConstructorsJSON(this.constructors),
           metatheoremsJSON = metatheoremsToMetatheoremsJSON(this.metatheorems),
           metavariablesJSON = metavariablesToMetavariablesJSON(this.metavariables),
@@ -933,6 +958,7 @@ export default class FileContext {
           variables = variablesJSON,  ///
           conjectures = conjecturesJSON,  ///
           combinators = combinatorsJSON,  ///
+          typePrefixes = typePrefixesJSON,  ///
           constructors = constructorsJSON,  ///
           metatheorems = metatheoremsJSON,  ///
           metavariables = metavariablesJSON,  ///
@@ -945,6 +971,7 @@ export default class FileContext {
             variables,
             conjectures,
             combinators,
+            typePrefixes,
             constructors,
             metatheorems,
             metavariables
@@ -967,10 +994,11 @@ export default class FileContext {
           metaLemmas = [],
           conjectures = [],
           combinators = [],
+          typePrefixes = [],
           constructors = [],
           metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
 
     return fileContext;
   }
@@ -988,10 +1016,11 @@ export default class FileContext {
           metaLemmas = null,
           conjectures = null,
           combinators = null,
+          typePrefixes = null,
           constructors = null,
           metatheorems = null,
           metavariables = null,
-          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
 
     fileContext.initialise(json);
 

package/src/dom/assertion/type.js

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

package/src/dom/variable.js

@@ -92,11 +92,12 @@ export default domAssigned(class Variable {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeString = this.type.getString();
+    const typeName = this.tyupe.getName(),
+          typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' type...`);
 
-    const type = context.findTypeByTypeName(typeString);
+    const type = context.findTypeByTypeName(typeName);
 
     if (type === null) {
       context.debug(`The '${typeString}' type is not present.`);

package/src/node/type.js

@@ -22,5 +22,24 @@ export default class TypeNode extends NonTerminalNode {
     return typeName;
   }
 
+  getTypePrefix() {
+    let typePrefix;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+          content = terminalNode.getContent();
+
+        typePrefix = content; ///
+
+        return true;
+      }
+    });
+
+    return typePrefix;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/typePrefix.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+export default class TypePrefixNode extends NonTerminalNode {
+  getTypePrefix() {
+    let typePrefix;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent();
+
+        typePrefix = content; ///
+
+        return true;
+      }
+    });
+
+    return typePrefix;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypePrefixNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/utilities/json.js

@@ -372,6 +372,22 @@ export function combinatorsFromJSON(json, context) {
   return combinators;
 }
 
+export function typePrefixesFromJSON(json, context) {
+  let { typePrefixes } = json;
+
+  const { TypePrefix } = dom,
+        typePrefixesJSON = typePrefixes; ///
+
+  typePrefixes = typePrefixesJSON.map((typePrefixJSON) => {
+    const json = typePrefixJSON,  ///
+          typePrefix = TypePrefix.fromJSON(json, context);
+
+    return typePrefix;
+  });
+
+  return typePrefixes;
+}
+
 export function constructorsFromJSON(json, context) {
   let { constructors } = json;
 
@@ -680,6 +696,18 @@ export function propertiesToPropertiesJSON(properties) {
   return propertiesJSON;
 }
 
+export function typePrefixesToTypePrefixesJSON(typePrefixes) {
+  const typePrefixesJSON = typePrefixes.map((typePrefix) => {
+    const typePrefixJSON = typePrefix.toJSON();
+
+    typePrefix = typePrefixJSON; ///
+
+    return typePrefix;
+  });
+
+  return typePrefixesJSON;
+}
+
 export function conjecturesToConjecturesJSON(conjectures) {
   const conjecturesJSON = conjectures.map((conjecture) => {
     const conjectureJSON = conjecture.toJSON();