occam-verify-cli 1.0.316 → 1.0.317

package/src/context/file.js

@@ -19,14 +19,14 @@ import { typesFromJSON,
          axiomsToAxiomsJSON,
          conjecturesFromJSON,
          combinatorsFromJSON,
-         typeAliasesFromJSON,
+         typePrefixesFromJSON,
          constructorsFromJSON,
          metatheoremsFromJSON,
          metavariablesFromJSON,
          metaLemmasFromNothing,
          theoremsToTheoremsJSON,
          variablesToVariablesJSON,
-         typeAliasesToTypeAliasesJSON,
+         typePrefixesToTypePrefixesJSON,
          conjecturesToConjecturesJSON,
          combinatorsToCombinatorsJSON,
          constructorsToConstructorsJSON,
@@ -36,7 +36,7 @@ import { typesFromJSON,
 const { push, first, filter } = arrayUtilities;
 
 export default class FileContext {
-  constructor(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typeAliases, 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;
@@ -51,7 +51,7 @@ export default class FileContext {
     this.metaLemmas = metaLemmas;
     this.conjectures = conjectures;
     this.combinators = combinators;
-    this.typeAliases = typeAliases;
+    this.typePrefixes = typePrefixes;
     this.constructors = constructors;
     this.metatheorems = metatheorems;
     this.metavariables = metavariables;
@@ -277,8 +277,8 @@ export default class FileContext {
     return combinators;
   }
 
-  getTypeAliases(includeRelease = true) {
-    return this.typeAliases;
+  getTypePrefixes(includeRelease = true) {
+    return this.typePrefixes;
   }
 
   getConstructors(includeRelease = true) {
@@ -319,18 +319,18 @@ export default class FileContext {
     return fileContext;
   }
 
-  getTypeAlias() {
-    let typeAlias = null;
+  getTypePrefix() {
+    let typePrefix = null;
 
-    const typeAliasesLength = this.typeAliases.length;
+    const typePrefixesLength = this.typePrefixes.length;
 
-    if (typeAliasesLength === 1) {
-      const firstTypeAlias = first(this.typeAliases);
+    if (typePrefixesLength === 1) {
+      const firstTypePrefix = first(this.typePrefixes);
 
-      typeAlias = firstTypeAlias; ///
+      typePrefix = firstTypePrefix; ///
     }
 
-    return typeAlias;
+    return typePrefix;
   }
 
   addType(type) {
@@ -883,7 +883,7 @@ export default class FileContext {
     this.metaLemmas = [];
     this.conjectures = [];
     this.combinators = [];
-    this.typeAliases = [];
+    this.typePrefixes = [];
     this.constructors = [];
     this.metatheorems = [];
     this.metavariables = [];
@@ -929,7 +929,7 @@ export default class FileContext {
 
     this.combinators = combinatorsFromJSON(json, fileContext);
 
-    this.typeAliases = typeAliasesFromJSON(json, fileContext);
+    this.typePrefixes = typePrefixesFromJSON(json, fileContext);
 
     this.constructors = constructorsFromJSON(json, fileContext);
 
@@ -946,7 +946,7 @@ export default class FileContext {
           variablesJSON = variablesToVariablesJSON(this.variables),
           conjecturesJSON = conjecturesToConjecturesJSON(this.conjectures),
           combinatorsJSON = combinatorsToCombinatorsJSON(this.combinators),
-          typeAliasesJSON = typeAliasesToTypeAliasesJSON(this.typeAliases),
+          typePrefixesJSON = typePrefixesToTypePrefixesJSON(this.typePrefixes),
           constructorsJSON = constructorsToConstructorsJSON(this.constructors),
           metatheoremsJSON = metatheoremsToMetatheoremsJSON(this.metatheorems),
           metavariablesJSON = metavariablesToMetavariablesJSON(this.metavariables),
@@ -958,7 +958,7 @@ export default class FileContext {
           variables = variablesJSON,  ///
           conjectures = conjecturesJSON,  ///
           combinators = combinatorsJSON,  ///
-          typeAliases = typeAliasesJSON,  ///
+          typePrefixes = typePrefixesJSON,  ///
           constructors = constructorsJSON,  ///
           metatheorems = metatheoremsJSON,  ///
           metavariables = metavariablesJSON,  ///
@@ -971,7 +971,7 @@ export default class FileContext {
             variables,
             conjectures,
             combinators,
-            typeAliases,
+            typePrefixes,
             constructors,
             metatheorems,
             metavariables
@@ -994,11 +994,11 @@ export default class FileContext {
           metaLemmas = [],
           conjectures = [],
           combinators = [],
-          typeAliases = [],
+          typePrefixes = [],
           constructors = [],
           metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typeAliases, 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;
   }
@@ -1016,11 +1016,11 @@ export default class FileContext {
           metaLemmas = null,
           conjectures = null,
           combinators = null,
-          typeAliases = 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, typeAliases, 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,20 +372,20 @@ export function combinatorsFromJSON(json, context) {
   return combinators;
 }
 
-export function typeAliasesFromJSON(json, context) {
-  let { typeAliases } = json;
+export function typePrefixesFromJSON(json, context) {
+  let { typePrefixes } = json;
 
-  const { TypeAlias } = dom,
-        typeAliasesJSON = typeAliases; ///
+  const { TypePrefix } = dom,
+        typePrefixesJSON = typePrefixes; ///
 
-  typeAliases = typeAliasesJSON.map((typeAliasJSON) => {
-    const json = typeAliasJSON,  ///
-          typeAlias = TypeAlias.fromJSON(json, context);
+  typePrefixes = typePrefixesJSON.map((typePrefixJSON) => {
+    const json = typePrefixJSON,  ///
+          typePrefix = TypePrefix.fromJSON(json, context);
 
-    return typeAlias;
+    return typePrefix;
   });
 
-  return typeAliases;
+  return typePrefixes;
 }
 
 export function constructorsFromJSON(json, context) {
@@ -696,16 +696,16 @@ export function propertiesToPropertiesJSON(properties) {
   return propertiesJSON;
 }
 
-export function typeAliasesToTypeAliasesJSON(typeAliases) {
-  const typeAliasesJSON = typeAliases.map((typeAlias) => {
-    const typeAliasJSON = typeAlias.toJSON();
+export function typePrefixesToTypePrefixesJSON(typePrefixes) {
+  const typePrefixesJSON = typePrefixes.map((typePrefix) => {
+    const typePrefixJSON = typePrefix.toJSON();
 
-    typeAlias = typeAliasJSON; ///
+    typePrefix = typePrefixJSON; ///
 
-    return typeAlias;
+    return typePrefix;
   });
 
-  return typeAliasesJSON;
+  return typePrefixesJSON;
 }
 
 export function conjecturesToConjecturesJSON(conjectures) {