occam-verify-cli 0.0.697 → 0.0.700

package/src/verify/typeAssertion.js

@@ -2,164 +2,133 @@
 
 import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
+import verifyTermAndStandaloneType from "../verify/termAndStandaloneType";
+import verifyTermAsVariableAndStandaloneType from "../verify/termAsVariableAndStandaloneType";
 
 import { first } from "../utilities/array";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../verify/term";
+import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!");
 
 export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
-  let typeAssertionVerified = false;
+  let typeAssertionVerified;
 
   const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
   context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
-  const typeNode = typeNodeQuery(typeAssertionNode),
-        typeName = typeNameFromTypeNode(typeNode),
-        assertedTypeName = typeName,  ///
-        assertedType = context.findTypeByTypeName(assertedTypeName);
-
-  if (assertedType === null) {
-    context.debug(`The '${typeName}' asserted type is not present.`, typeAssertionNode);
-  } else {
-    const verifyTypeAssertionFunctions = [
-      verifyVariableTypeAssertion,
-      verifyTermTypeAssertion
-    ];
-
-    typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
-      const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead);
-
-      if (typeAssertionVerified) {
-        return true;
-      }
-    });
-  }
+  const verifyTypeAssertionFunctions = [
+    verifyDerivedTypeAssertion,
+    verifyGivenTypeAssertion
+  ];
+
+  typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
+    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, context, verifyAhead);
+
+    if (typeAssertionVerified) {
+      return true;
+    }
+  });
 
   if (typeAssertionVerified) {
-    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+    context.debug(`...verified the '${typeAssertionString}' type assertion.`, typeAssertionNode);
   }
 
   return typeAssertionVerified;
 }
 
-export function verifyVariableTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
-  let variableTypeAssertionVerified;
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
+  let derivedTypeAssertionVerified = false;
 
-  const typeAssertionString = context.nodeAsString(typeAssertionNode);
+  if (derived) {
+    const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);
+    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
 
-  const variables = [],
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
-          let verifiedAhead = false;
+    const terms = [],
+          types = [],
+          termNode = termNodeQuery(typeAssertionNode),
+          typeNode = typeNodeQuery(typeAssertionNode),
+          termAndStandaloneTypeVerified = verifyTermAndStandaloneType(termNode, typeNode, terms, types, context, () => {
+            let verifiedAhead = false;
 
-          const firstVariable = first(variables),
-                variable = firstVariable, ///
-                variableName = variable.getName(),
-                variableType = variable.getType();
+            const firstTerm = first(terms),
+                  firstType = first(types),
+                  term = firstTerm, ///
+                  type = firstType, ///
+                  termType = term.getType(),
+                  termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);
 
-          if (derived) {
-            const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
-
-            if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
-              const assertedTypeName = assertedType.getName(),
-                    variableTypeName = variableType.getName();
-
-              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-            } else {
-              verifiedAhead = verifyAhead();
-            }
-          } else {
-            const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
-
-            if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-              const assertedTypeName = assertedType.getName(),
-                    variableTypeName = variableType.getName();
-
-              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-            } else {
-              const name = variableName,  ///
-                    type = assertedType,  ///
-                    variable = Variable.fromNameAndType(name, type),
-                    variableAssignment = VariableAssignment.fromVariable(variable),
-                    assignment = variableAssignment; ///
-
-              assignments.push(assignment);
-
-              verifiedAhead = verifyAhead();
+            if (termTypeEqualToOrSuperTypeOfType) {
+              debugger
 
-              if (!verifiedAhead) {
-                assignments.pop();
+              if (false) {  ///
+                verifiedAhead = verifyAhead();
               }
             }
-          }
 
-          return verifiedAhead;
-        });
+            return verifiedAhead;
+          });
 
-  variableTypeAssertionVerified = termVerifiedAsVariable; ///
+    derivedTypeAssertionVerified = termAndStandaloneTypeVerified; ///
 
-  if (variableTypeAssertionVerified) {
-    context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);
+    if (derivedTypeAssertionVerified) {
+      context.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
+    }
   }
 
-  return variableTypeAssertionVerified;
+  return derivedTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
-  let termTypeAssertionVerified;
+function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
+  let givenTypeAssertionVerified = false;
 
-  const typeAssertionString = context.nodeAsString(typeAssertionNode);
+  if (!derived) {
+    const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);
+    context.trace(`Verifying the '${typeAssertionString}' given type assertion...`, typeAssertionNode);
 
-  const types = [],
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context, () => {
-          let verifiedAhead = false;
+    const types = [],
+          variables = [],
+          termNode = termNodeQuery(typeAssertionNode),
+          typeNode = typeNodeQuery(typeAssertionNode),
+          termAsVariableAndStandaloneTypeVerified = verifyTermAsVariableAndStandaloneType(termNode, typeNode, variables, types, context, () => {
+            let verifiedAhead = false;
 
-          const firstType = first(types),
-                termType = firstType; ///
+            const firstVariable = first(variables);
 
-          if (derived) {
-            const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
+            let variable = firstVariable; ///
 
-            if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
-              const termString = context.nodeAsString(termNode),
-                    termTypeName = termType.getName(),
-                    assertedTypeName = assertedType.getName();
+            const firstType = first(types),
+                  type = firstType, ///
+                  variableType = variable.getType(),
+                  variableTypeEqualToOrSuperTypeOfType = variableType.isEqualToOrSuperTypeOf(type);
 
-              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
-            } else {
-              verifiedAhead = verifyAhead();
-            }
-          } else {
-            const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+            if (variableTypeEqualToOrSuperTypeOfType) {
+              variable = Variable.fromVariableAndType(variable, type);  ///
+
+              const variableAssignment = VariableAssignment.fromVariable(variable),
+                    assignment = variableAssignment; ///
 
-            if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
-              const termString = context.nodeAsString(termNode),
-                    termTypeName = termType.getName(),
-                    assertedTypeName = assertedType.getName();
+              assignments.push(assignment);
 
-              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
-            } else {
               verifiedAhead = verifyAhead();
+
+              if (!verifiedAhead) {
+                assignments.pop();
+              }
             }
-          }
 
-          return verifiedAhead;
-        });
+            return verifiedAhead;
+          });
 
-  termTypeAssertionVerified = termVerifiedAgainstConstructors;  ///
+    givenTypeAssertionVerified = termAsVariableAndStandaloneTypeVerified; ///
 
-  if (termTypeAssertionVerified) {
-    context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);
+    if (givenTypeAssertionVerified) {
+      context.trace(`...verified the '${typeAssertionString}' given type assertion.`, typeAssertionNode);
+    }
   }
 
-  return termTypeAssertionVerified;
+  return givenTypeAssertionVerified;
 }

package/src/verify/variable.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import Variable from "../variable";
+import VariableAssignment from "../assignment/variable";
 
 import { objectType } from "../type";
-import { typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
+import { typeNameFromTypeNode } from "../utilities/query";
 
 export default function verifyVariable(variableNode, typeNode, fileContext) {
   let variableVerified = false;
@@ -12,37 +13,36 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
 
   fileContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
 
-  const variableName = variableNameFromVariableNode(variableNode),
-        variablePresent = fileContext.isVariablePresentByVariableName(variableName);
+  const variablePresent = fileContext.isVariablePresentByVariableNode(variableNode);
 
   if (variablePresent) {
-    fileContext.debug(`The variable '${variableName}' is already present.`, variableNode);
+    fileContext.debug(`The variable '${variableString}' is already present.`, variableNode);
   } else {
     let variable;
 
     const typeName = typeNameFromTypeNode(typeNode);
     
     if (typeName === null) {
-      const name = variableName,  ///
-            type = objectType;
+      const type = objectType;
 
-        variable = Variable.fromNameAndType(name, type);
+      variable = Variable.fromVariableNodeAndType(variableNode, type);
     } else {
       const type = fileContext.findTypeByTypeName(typeName);
 
       if (type === null) {
-        fileContext.debug(`The '${variableName}' variable's '${typeName}' type is not present.`, variableNode);
+        fileContext.debug(`The '${variableString}' variable's '${typeName}' type is not present.`, variableNode);
       } else {
-        const name = variableName;  ///
-
-        variable = Variable.fromNameAndType(name, type);
+        variable = Variable.fromVariableNodeAndType(variableNode, type);
       }
     }
 
     if (variable !== null) {
-      fileContext.addVariable(variable);
+      const variableAssignment = VariableAssignment.fromVariable(variable),
+            variableAssigned = variableAssignment.assign(fileContext);
 
-      variableVerified = true;
+      if (variableAssigned) {
+        variableVerified = true;
+      }
     }
   }
 

package/lib/mixins/file.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-function getAxioms() {
-    return this.context.getAxioms();
-}
-function getLemmas() {
-    return this.context.getLemmas();
-}
-function getTheorems() {
-    return this.context.getTheorems();
-}
-function getConjectures() {
-    return this.context.getConjectures();
-}
-function getCombinators() {
-    return this.context.getCombinators();
-}
-function getConstructors() {
-    return this.context.getConstructors();
-}
-function findTypeByTypeName(typeName) {
-    return this.context.findTypeByTypeName(typeName);
-}
-function findLabelByTypeName(labelName) {
-    return this.context.findLabelByTypeName(labelName);
-}
-function findRuleByReferenceName(referenceName) {
-    return this.context.findRuleByReferenceName(referenceName);
-}
-function findAxiomByReferenceName(referenceName) {
-    return this.context.findAxiomByReferenceName(referenceName);
-}
-function findLemmaByReferenceName(referenceName) {
-    return this.context.findLemmaByReferenceName(referenceName);
-}
-function findTheoremByReferenceName(referenceName) {
-    return this.context.findTheoremByReferenceName(referenceName);
-}
-function findConjectureByReferenceName(referenceName) {
-    return this.context.findConjectureByReferenceName(referenceName);
-}
-function isLabelPresentByLabelName(labelName) {
-    return this.context.isLabelPresentByLabelName(labelName);
-}
-function isTypePresentByTypeName(typeName) {
-    return this.context.isTypePresentByTypeName(typeName);
-}
-function nodeAsString(node) {
-    return this.context.nodeAsString(node);
-}
-function nodesAsString(node) {
-    return this.context.nodesAsString(node);
-}
-var fileMixins = {
-    getAxioms: getAxioms,
-    getLemmas: getLemmas,
-    getTheorems: getTheorems,
-    getConjectures: getConjectures,
-    getCombinators: getCombinators,
-    getConstructors: getConstructors,
-    findTypeByTypeName: findTypeByTypeName,
-    findLabelByTypeName: findLabelByTypeName,
-    findRuleByReferenceName: findRuleByReferenceName,
-    findAxiomByReferenceName: findAxiomByReferenceName,
-    findLemmaByReferenceName: findLemmaByReferenceName,
-    findTheoremByReferenceName: findTheoremByReferenceName,
-    findConjectureByReferenceName: findConjectureByReferenceName,
-    isLabelPresentByLabelName: isLabelPresentByLabelName,
-    isTypePresentByTypeName: isTypePresentByTypeName,
-    nodeAsString: nodeAsString,
-    nodesAsString: nodesAsString
-};
-var _default = fileMixins;
-
-//# sourceMappingURL=data:application/json;base64,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

package/lib/mixins/logging.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-function trace(node, message) {
-    this.context.trace(node, message);
-}
-function debug(node, message) {
-    this.context.debug(node, message);
-}
-function info(node, message) {
-    this.context.info(node, message);
-}
-function warning(node, message) {
-    this.context.warning(node, message);
-}
-function error(node, message) {
-    this.context.error(node, message);
-}
-function fatal(node, message) {
-    this.context.fatal(node, message);
-}
-var loggingMixins = {
-    trace: trace,
-    debug: debug,
-    info: info,
-    warning: warning,
-    error: error,
-    fatal: fatal
-};
-var _default = loggingMixins;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9taXhpbnMvbG9nZ2luZy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZnVuY3Rpb24gdHJhY2Uobm9kZSwgbWVzc2FnZSkgeyB0aGlzLmNvbnRleHQudHJhY2Uobm9kZSwgbWVzc2FnZSk7IH1cblxuZnVuY3Rpb24gZGVidWcobm9kZSwgbWVzc2FnZSkgeyB0aGlzLmNvbnRleHQuZGVidWcobm9kZSwgbWVzc2FnZSk7IH1cblxuZnVuY3Rpb24gaW5mbyhub2RlLCBtZXNzYWdlKSB7IHRoaXMuY29udGV4dC5pbmZvKG5vZGUsIG1lc3NhZ2UpOyB9XG5cbmZ1bmN0aW9uIHdhcm5pbmcobm9kZSwgbWVzc2FnZSkgeyB0aGlzLmNvbnRleHQud2FybmluZyhub2RlLCBtZXNzYWdlKTsgfVxuXG5mdW5jdGlvbiBlcnJvcihub2RlLCBtZXNzYWdlKSB7IHRoaXMuY29udGV4dC5lcnJvcihub2RlLCBtZXNzYWdlKTsgfVxuXG5mdW5jdGlvbiBmYXRhbChub2RlLCBtZXNzYWdlKSB7IHRoaXMuY29udGV4dC5mYXRhbChub2RlLCBtZXNzYWdlKTsgfVxuXG5jb25zdCBsb2dnaW5nTWl4aW5zID0ge1xuICB0cmFjZSxcbiAgZGVidWcsXG4gIGluZm8sXG4gIHdhcm5pbmcsXG4gIGVycm9yLFxuICBmYXRhbFxufTtcblxuZXhwb3J0IGRlZmF1bHQgbG9nZ2luZ01peGlucztcbiJdLCJuYW1lcyI6WyJ0cmFjZSIsIm5vZGUiLCJtZXNzYWdlIiwiY29udGV4dCIsImRlYnVnIiwiaW5mbyIsIndhcm5pbmciLCJlcnJvciIsImZhdGFsIiwibG9nZ2luZ01peGlucyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBdUJBOzs7ZUFBQTs7O0FBckJBLFNBQVNBLE1BQU1DLElBQUksRUFBRUMsT0FBTztJQUFJLElBQUksQ0FBQ0MsT0FBTyxDQUFDSCxLQUFLLENBQUNDLE1BQU1DO0FBQVU7QUFFbkUsU0FBU0UsTUFBTUgsSUFBSSxFQUFFQyxPQUFPO0lBQUksSUFBSSxDQUFDQyxPQUFPLENBQUNDLEtBQUssQ0FBQ0gsTUFBTUM7QUFBVTtBQUVuRSxTQUFTRyxLQUFLSixJQUFJLEVBQUVDLE9BQU87SUFBSSxJQUFJLENBQUNDLE9BQU8sQ0FBQ0UsSUFBSSxDQUFDSixNQUFNQztBQUFVO0FBRWpFLFNBQVNJLFFBQVFMLElBQUksRUFBRUMsT0FBTztJQUFJLElBQUksQ0FBQ0MsT0FBTyxDQUFDRyxPQUFPLENBQUNMLE1BQU1DO0FBQVU7QUFFdkUsU0FBU0ssTUFBTU4sSUFBSSxFQUFFQyxPQUFPO0lBQUksSUFBSSxDQUFDQyxPQUFPLENBQUNJLEtBQUssQ0FBQ04sTUFBTUM7QUFBVTtBQUVuRSxTQUFTTSxNQUFNUCxJQUFJLEVBQUVDLE9BQU87SUFBSSxJQUFJLENBQUNDLE9BQU8sQ0FBQ0ssS0FBSyxDQUFDUCxNQUFNQztBQUFVO0FBRW5FLElBQU1PLGdCQUFnQjtJQUNwQlQsT0FBQUE7SUFDQUksT0FBQUE7SUFDQUMsTUFBQUE7SUFDQUMsU0FBQUE7SUFDQUMsT0FBQUE7SUFDQUMsT0FBQUE7QUFDRjtJQUVBLFdBQWVDIn0=

package/src/mixins/logging.js

@@ -1,24 +0,0 @@
-"use strict";
-
-function trace(node, message) { this.context.trace(node, message); }
-
-function debug(node, message) { this.context.debug(node, message); }
-
-function info(node, message) { this.context.info(node, message); }
-
-function warning(node, message) { this.context.warning(node, message); }
-
-function error(node, message) { this.context.error(node, message); }
-
-function fatal(node, message) { this.context.fatal(node, message); }
-
-const loggingMixins = {
-  trace,
-  debug,
-  info,
-  warning,
-  error,
-  fatal
-};
-
-export default loggingMixins;