occam-verify-cli 0.0.697 → 0.0.700

package/lib/verify/typeAssertion.js

@@ -2,25 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    default: function() {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
         return verifyTypeAssertion;
-    },
-    verifyVariableTypeAssertion: function() {
-        return verifyVariableTypeAssertion;
     }
 });
 var _variable = /*#__PURE__*/ _interop_require_default(require("../variable"));
 var _variable1 = /*#__PURE__*/ _interop_require_default(require("../assignment/variable"));
+var _termAndStandaloneType = /*#__PURE__*/ _interop_require_default(require("../verify/termAndStandaloneType"));
+var _termAsVariableAndStandaloneType = /*#__PURE__*/ _interop_require_default(require("../verify/termAsVariableAndStandaloneType"));
 var _array = require("../utilities/array");
 var _query = require("../utilities/query");
-var _term = require("../verify/term");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -28,97 +21,74 @@ function _interop_require_default(obj) {
 }
 var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term!"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type!");
 function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
-    var typeAssertionVerified = false;
+    var typeAssertionVerified;
     var typeAssertionString = context.nodeAsString(typeAssertionNode);
     context.trace("Verifying the '".concat(typeAssertionString, "' type assertion..."), typeAssertionNode);
-    var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = context.findTypeByTypeName(assertedTypeName);
-    if (assertedType === null) {
-        context.debug("The '".concat(typeName, "' asserted type is not present."), typeAssertionNode);
-    } else {
-        var verifyTypeAssertionFunctions = [
-            verifyVariableTypeAssertion,
-            verifyTermTypeAssertion
-        ];
-        typeAssertionVerified = verifyTypeAssertionFunctions.some(function(verifyTypeAssertionFunction) {
-            var typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead);
-            if (typeAssertionVerified) {
-                return true;
-            }
-        });
-    }
+    var verifyTypeAssertionFunctions = [
+        verifyDerivedTypeAssertion,
+        verifyGivenTypeAssertion
+    ];
+    typeAssertionVerified = verifyTypeAssertionFunctions.some(function(verifyTypeAssertionFunction) {
+        var typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, context, verifyAhead);
+        if (typeAssertionVerified) {
+            return true;
+        }
+    });
     if (typeAssertionVerified) {
-        context.debug("...verified the '".concat(typeAssertionString, "' statement type assertion."), typeAssertionNode);
+        context.debug("...verified the '".concat(typeAssertionString, "' type assertion."), typeAssertionNode);
     }
     return typeAssertionVerified;
 }
-function verifyVariableTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
-    var variableTypeAssertionVerified;
-    var typeAssertionString = context.nodeAsString(typeAssertionNode);
-    context.trace("Verifying the '".concat(typeAssertionString, "' variable type assertion..."), typeAssertionNode);
-    var variables = [], termNode = termNodeQuery(typeAssertionNode), termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context, function() {
-        var verifiedAhead = false;
-        var firstVariable = (0, _array.first)(variables), variable = firstVariable, variableName = variable.getName(), variableType = variable.getType();
-        if (derived) {
-            var assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
-            if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
-                var assertedTypeName = assertedType.getName(), variableTypeName = variableType.getName();
-                context.debug("The '".concat(assertedTypeName, "' asserted type is not equal to or a super-type of the '").concat(variableName, "' variable's '").concat(variableTypeName, "' type."), typeAssertionNode);
-            } else {
-                verifiedAhead = verifyAhead();
-            }
-        } else {
-            var assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
-            if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-                var assertedTypeName1 = assertedType.getName(), variableTypeName1 = variableType.getName();
-                context.debug("The '".concat(assertedTypeName1, "' asserted type is not equal to or a sub-type of the '").concat(variableName, "' variable's '").concat(variableTypeName1, "' type."), typeAssertionNode);
-            } else {
-                var name = variableName, type = assertedType, variable1 = _variable.default.fromNameAndType(name, type), variableAssignment = _variable1.default.fromVariable(variable1), assignment = variableAssignment; ///
-                assignments.push(assignment);
-                verifiedAhead = verifyAhead();
-                if (!verifiedAhead) {
-                    assignments.pop();
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
+    var derivedTypeAssertionVerified = false;
+    if (derived) {
+        var typeAssertionString = context.nodeAsString(typeAssertionNode);
+        context.trace("Verifying the '".concat(typeAssertionString, "' derived type assertion..."), typeAssertionNode);
+        var terms = [], types = [], termNode = termNodeQuery(typeAssertionNode), typeNode = typeNodeQuery(typeAssertionNode), termAndStandaloneTypeVerified = (0, _termAndStandaloneType.default)(termNode, typeNode, terms, types, context, function() {
+            var verifiedAhead = false;
+            var firstTerm = (0, _array.first)(terms), firstType = (0, _array.first)(types), term = firstTerm, type = firstType, termType = term.getType(), termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);
+            if (termTypeEqualToOrSuperTypeOfType) {
+                debugger;
+                if (false) {
+                    verifiedAhead = verifyAhead();
                 }
             }
+            return verifiedAhead;
+        });
+        derivedTypeAssertionVerified = termAndStandaloneTypeVerified; ///
+        if (derivedTypeAssertionVerified) {
+            context.trace("...verified the '".concat(typeAssertionString, "' derived type assertion."), typeAssertionNode);
         }
-        return verifiedAhead;
-    });
-    variableTypeAssertionVerified = termVerifiedAsVariable; ///
-    if (variableTypeAssertionVerified) {
-        context.debug("...verified the '".concat(typeAssertionString, "' variable type assertion."), typeAssertionNode);
     }
-    return variableTypeAssertionVerified;
+    return derivedTypeAssertionVerified;
 }
-function verifyTermTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
-    var termTypeAssertionVerified;
-    var typeAssertionString = context.nodeAsString(typeAssertionNode);
-    context.trace("Verifying the '".concat(typeAssertionString, "' term type assertion..."), typeAssertionNode);
-    var types = [], termNode = termNodeQuery(typeAssertionNode), termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context, function() {
-        var verifiedAhead = false;
-        var firstType = (0, _array.first)(types), termType = firstType; ///
-        if (derived) {
-            var assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
-            if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
-                var termString = context.nodeAsString(termNode), termTypeName = termType.getName(), assertedTypeName = assertedType.getName();
-                context.debug("The '".concat(assertedTypeName, "' asserted type is not equal to or a super-type of the '").concat(termString, "' term's '").concat(termTypeName, "' type."), typeAssertionNode);
-            } else {
-                verifiedAhead = verifyAhead();
-            }
-        } else {
-            var assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
-            if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
-                var termString1 = context.nodeAsString(termNode), termTypeName1 = termType.getName(), assertedTypeName1 = assertedType.getName();
-                context.debug("The '".concat(assertedTypeName1, "' asserted type is not equal to or a sub-type of the '").concat(termString1, "' term's '").concat(termTypeName1, "' type."), typeAssertionNode);
-            } else {
+function verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
+    var givenTypeAssertionVerified = false;
+    if (!derived) {
+        var typeAssertionString = context.nodeAsString(typeAssertionNode);
+        context.trace("Verifying the '".concat(typeAssertionString, "' given type assertion..."), typeAssertionNode);
+        var types = [], variables = [], termNode = termNodeQuery(typeAssertionNode), typeNode = typeNodeQuery(typeAssertionNode), termAsVariableAndStandaloneTypeVerified = (0, _termAsVariableAndStandaloneType.default)(termNode, typeNode, variables, types, context, function() {
+            var verifiedAhead = false;
+            var firstVariable = (0, _array.first)(variables);
+            var variable = firstVariable; ///
+            var firstType = (0, _array.first)(types), type = firstType, variableType = variable.getType(), variableTypeEqualToOrSuperTypeOfType = variableType.isEqualToOrSuperTypeOf(type);
+            if (variableTypeEqualToOrSuperTypeOfType) {
+                variable = _variable.default.fromVariableAndType(variable, type); ///
+                var variableAssignment = _variable1.default.fromVariable(variable), assignment = variableAssignment; ///
+                assignments.push(assignment);
                 verifiedAhead = verifyAhead();
+                if (!verifiedAhead) {
+                    assignments.pop();
+                }
             }
+            return verifiedAhead;
+        });
+        givenTypeAssertionVerified = termAsVariableAndStandaloneTypeVerified; ///
+        if (givenTypeAssertionVerified) {
+            context.trace("...verified the '".concat(typeAssertionString, "' given type assertion."), typeAssertionNode);
         }
-        return verifiedAhead;
-    });
-    termTypeAssertionVerified = termVerifiedAgainstConstructors; ///
-    if (termTypeAssertionVerified) {
-        context.debug("...verified the '".concat(typeAssertionString, "' term type assertion."), typeAssertionNode);
     }
-    return termTypeAssertionVerified;
+    return givenTypeAssertionVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/typeAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../variable\";\nimport VariableAssignment from \"../assignment/variable\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../verify/term\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term!\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type!\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {\n  let typeAssertionVerified = false;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        assertedTypeName = typeName,  ///\n        assertedType = context.findTypeByTypeName(assertedTypeName);\n\n  if (assertedType === null) {\n    context.debug(`The '${typeName}' asserted type is not present.`, typeAssertionNode);\n  } else {\n    const verifyTypeAssertionFunctions = [\n      verifyVariableTypeAssertion,\n      verifyTermTypeAssertion\n    ];\n\n    typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {\n      const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead);\n\n      if (typeAssertionVerified) {\n        return true;\n      }\n    });\n  }\n\n  if (typeAssertionVerified) {\n    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);\n  }\n\n  return typeAssertionVerified;\n}\n\nexport function verifyVariableTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {\n  let variableTypeAssertionVerified;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);\n\n  const variables = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {\n          let verifiedAhead = false;\n\n          const firstVariable = first(variables),\n                variable = firstVariable, ///\n                variableName = variable.getName(),\n                variableType = variable.getType();\n\n          if (derived) {\n            const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);\n\n            if (!assertedTypeEqualToOrSuperTypeOfVariableType) {\n              const assertedTypeName = assertedType.getName(),\n                    variableTypeName = variableType.getName();\n\n              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n            } else {\n              verifiedAhead = verifyAhead();\n            }\n          } else {\n            const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);\n\n            if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n              const assertedTypeName = assertedType.getName(),\n                    variableTypeName = variableType.getName();\n\n              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);\n            } else {\n              const name = variableName,  ///\n                    type = assertedType,  ///\n                    variable = Variable.fromNameAndType(name, type),\n                    variableAssignment = VariableAssignment.fromVariable(variable),\n                    assignment = variableAssignment; ///\n\n              assignments.push(assignment);\n\n              verifiedAhead = verifyAhead();\n\n              if (!verifiedAhead) {\n                assignments.pop();\n              }\n            }\n          }\n\n          return verifiedAhead;\n        });\n\n  variableTypeAssertionVerified = termVerifiedAsVariable; ///\n\n  if (variableTypeAssertionVerified) {\n    context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);\n  }\n\n  return variableTypeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {\n  let termTypeAssertionVerified;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);\n\n  const types = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context, () => {\n          let verifiedAhead = false;\n\n          const firstType = first(types),\n                termType = firstType; ///\n\n          if (derived) {\n            const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);\n\n            if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {\n              const termString = context.nodeAsString(termNode),\n                    termTypeName = termType.getName(),\n                    assertedTypeName = assertedType.getName();\n\n              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n            } else {\n              verifiedAhead = verifyAhead();\n            }\n          } else {\n            const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n            if (!assertedTypeIsEqualToOrSubTypeOfTermType) {\n              const termString = context.nodeAsString(termNode),\n                    termTypeName = termType.getName(),\n                    assertedTypeName = assertedType.getName();\n\n              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);\n            } else {\n              verifiedAhead = verifyAhead();\n            }\n          }\n\n          return verifiedAhead;\n        });\n\n  termTypeAssertionVerified = termVerifiedAgainstConstructors;  ///\n\n  if (termTypeAssertionVerified) {\n    context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);\n  }\n\n  return termTypeAssertionVerified;\n}\n"],"names":["verifyTypeAssertion","verifyVariableTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","assignments","derived","context","verifyAhead","typeAssertionVerified","typeAssertionString","nodeAsString","trace","typeNode","typeName","typeNameFromTypeNode","assertedTypeName","assertedType","findTypeByTypeName","debug","verifyTypeAssertionFunctions","verifyTermTypeAssertion","some","verifyTypeAssertionFunction","variableTypeAssertionVerified","variables","termNode","termVerifiedAsVariable","verifyTermAsVariable","verifiedAhead","firstVariable","first","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSuperTypeOfVariableType","isEqualToOrSuperTypeOf","variableTypeName","assertedTypeEqualToOrSubTypeOfVariableType","isEqualToOrSubTypeOf","name","type","Variable","fromNameAndType","variableAssignment","VariableAssignment","fromVariable","assignment","push","pop","termTypeAssertionVerified","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","firstType","termType","assertedTypeIsEqualToOrSuperTypeOfTermType","termString","termTypeName","assertedTypeIsEqualToOrSubTypeOfTermType"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/typeAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../variable\";\nimport VariableAssignment from \"../assignment/variable\";\nimport verifyTermAndStandaloneType from \"../verify/termAndStandaloneType\";\nimport verifyTermAsVariableAndStandaloneType from \"../verify/termAsVariableAndStandaloneType\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeQuery } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term!\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type!\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {\n  let typeAssertionVerified;\n\n  const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);\n\n  const verifyTypeAssertionFunctions = [\n    verifyDerivedTypeAssertion,\n    verifyGivenTypeAssertion\n  ];\n\n  typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {\n    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, context, verifyAhead);\n\n    if (typeAssertionVerified) {\n      return true;\n    }\n  });\n\n  if (typeAssertionVerified) {\n    context.debug(`...verified the '${typeAssertionString}' type assertion.`, typeAssertionNode);\n  }\n\n  return typeAssertionVerified;\n}\n\nfunction verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {\n  let derivedTypeAssertionVerified = false;\n\n  if (derived) {\n    const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);\n\n    const terms = [],\n          types = [],\n          termNode = termNodeQuery(typeAssertionNode),\n          typeNode = typeNodeQuery(typeAssertionNode),\n          termAndStandaloneTypeVerified = verifyTermAndStandaloneType(termNode, typeNode, terms, types, context, () => {\n            let verifiedAhead = false;\n\n            const firstTerm = first(terms),\n                  firstType = first(types),\n                  term = firstTerm, ///\n                  type = firstType, ///\n                  termType = term.getType(),\n                  termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);\n\n            if (termTypeEqualToOrSuperTypeOfType) {\n              debugger\n\n              if (false) {  ///\n                verifiedAhead = verifyAhead();\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    derivedTypeAssertionVerified = termAndStandaloneTypeVerified; ///\n\n    if (derivedTypeAssertionVerified) {\n      context.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return derivedTypeAssertionVerified;\n}\n\nfunction verifyGivenTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {\n  let givenTypeAssertionVerified = false;\n\n  if (!derived) {\n    const typeAssertionString = context.nodeAsString(typeAssertionNode);\n\n    context.trace(`Verifying the '${typeAssertionString}' given type assertion...`, typeAssertionNode);\n\n    const types = [],\n          variables = [],\n          termNode = termNodeQuery(typeAssertionNode),\n          typeNode = typeNodeQuery(typeAssertionNode),\n          termAsVariableAndStandaloneTypeVerified = verifyTermAsVariableAndStandaloneType(termNode, typeNode, variables, types, context, () => {\n            let verifiedAhead = false;\n\n            const firstVariable = first(variables);\n\n            let variable = firstVariable; ///\n\n            const firstType = first(types),\n                  type = firstType, ///\n                  variableType = variable.getType(),\n                  variableTypeEqualToOrSuperTypeOfType = variableType.isEqualToOrSuperTypeOf(type);\n\n            if (variableTypeEqualToOrSuperTypeOfType) {\n              variable = Variable.fromVariableAndType(variable, type);  ///\n\n              const variableAssignment = VariableAssignment.fromVariable(variable),\n                    assignment = variableAssignment; ///\n\n              assignments.push(assignment);\n\n              verifiedAhead = verifyAhead();\n\n              if (!verifiedAhead) {\n                assignments.pop();\n              }\n            }\n\n            return verifiedAhead;\n          });\n\n    givenTypeAssertionVerified = termAsVariableAndStandaloneTypeVerified; ///\n\n    if (givenTypeAssertionVerified) {\n      context.trace(`...verified the '${typeAssertionString}' given type assertion.`, typeAssertionNode);\n    }\n  }\n\n  return givenTypeAssertionVerified;\n}\n"],"names":["verifyTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","assignments","derived","context","verifyAhead","typeAssertionVerified","typeAssertionString","nodeAsString","trace","verifyTypeAssertionFunctions","verifyDerivedTypeAssertion","verifyGivenTypeAssertion","some","verifyTypeAssertionFunction","debug","derivedTypeAssertionVerified","terms","types","termNode","typeNode","termAndStandaloneTypeVerified","verifyTermAndStandaloneType","verifiedAhead","firstTerm","first","firstType","term","type","termType","getType","termTypeEqualToOrSuperTypeOfType","isEqualToOrSuperTypeOf","givenTypeAssertionVerified","variables","termAsVariableAndStandaloneTypeVerified","verifyTermAsVariableAndStandaloneType","firstVariable","variable","variableType","variableTypeEqualToOrSuperTypeOfType","Variable","fromVariableAndType","variableAssignment","VariableAssignment","fromVariable","assignment","push","pop"],"mappings":"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"}

package/lib/verify/variable.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _variable = /*#__PURE__*/ _interop_require_default(require("../variable"));
+var _variable1 = /*#__PURE__*/ _interop_require_default(require("../assignment/variable"));
 var _type = require("../type");
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
@@ -20,27 +21,28 @@ function verifyVariable(variableNode, typeNode, fileContext) {
     var variableVerified = false;
     var variableString = fileContext.nodeAsString(variableNode);
     fileContext.trace("Verifying the '".concat(variableString, "' variable..."), variableNode);
-    var variableName = (0, _query.variableNameFromVariableNode)(variableNode), variablePresent = fileContext.isVariablePresentByVariableName(variableName);
+    var variablePresent = fileContext.isVariablePresentByVariableNode(variableNode);
     if (variablePresent) {
-        fileContext.debug("The variable '".concat(variableName, "' is already present."), variableNode);
+        fileContext.debug("The variable '".concat(variableString, "' is already present."), variableNode);
     } else {
         var variable;
         var typeName = (0, _query.typeNameFromTypeNode)(typeNode);
         if (typeName === null) {
-            var name = variableName, type = _type.objectType;
-            variable = _variable.default.fromNameAndType(name, type);
+            var type = _type.objectType;
+            variable = _variable.default.fromVariableNodeAndType(variableNode, type);
         } else {
             var type1 = fileContext.findTypeByTypeName(typeName);
             if (type1 === null) {
-                fileContext.debug("The '".concat(variableName, "' variable's '").concat(typeName, "' type is not present."), variableNode);
+                fileContext.debug("The '".concat(variableString, "' variable's '").concat(typeName, "' type is not present."), variableNode);
             } else {
-                var name1 = variableName; ///
-                variable = _variable.default.fromNameAndType(name1, type1);
+                variable = _variable.default.fromVariableNodeAndType(variableNode, type1);
             }
         }
         if (variable !== null) {
-            fileContext.addVariable(variable);
-            variableVerified = true;
+            var variableAssignment = _variable1.default.fromVariable(variable), variableAssigned = variableAssignment.assign(fileContext);
+            if (variableAssigned) {
+                variableVerified = true;
+            }
         }
     }
     if (variableVerified) {
@@ -49,4 +51,4 @@ function verifyVariable(variableNode, typeNode, fileContext) {
     return variableVerified;
 }
 
-//# 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": "0.0.697",
+  "version": "0.0.700",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/assignment/equality.js

@@ -9,13 +9,22 @@ export default class EqualityAssignment {
     return this.equality;
   }
 
-  assign(localContext) {
-    localContext.addEquality(this.equality);
+  assign(context) {
+    const equalityAdded = context.addEquality(this.equality),
+          equalityNode = this.equality.getNode(),
+          equalityString = context.nodeAsString(equalityNode),
+          equalityAssigned = equalityAdded; ///
+
+    equalityAssigned ?
+      context.debug(`Able to assign the '${equalityString}' equality.`, equalityNode) :
+        context.trace(`Unable to assign the '${equalityString}' equality.`, equalityNode);
+
+    return equalityAssigned;
   }
 
   static fromEquality(equality) {
-    const assignmentAssignment = new EqualityAssignment(equality);
+    const equalityAssignment = new EqualityAssignment(equality);
 
-    return assignmentAssignment;
+    return equalityAssignment;
   }
 }

package/src/assignment/metavariable.js

@@ -0,0 +1,30 @@
+"use strict";
+
+export default class MetavariableAssignment {
+  constructor(metavariable) {
+    this.metavariable = metavariable;
+  }
+
+  getMetavariable() {
+    return this.metavariable;
+  }
+
+  assign(fileContext) {
+    const metavariableAdded = fileContext.addMetavariable(this.metavariable),
+          metavariableNode = this.metavariable.getNode(),
+          metavariableString = fileContext.nodeAsString(metavariableNode),
+          metavariableAssigned = metavariableAdded; ///
+
+    metavariableAssigned ?
+      fileContext.debug(`Able to assign the '${metavariableString}' metavariable.`, metavariableNode) :
+        fileContext.trace(`Unable to assign the '${metavariableString}' metavariable.`, metavariableNode);
+
+    return metavariableAssigned;
+  }
+
+  static fromMetavariable(metavariable) {
+    const metavariableAssignment = new MetavariableAssignment(metavariable);
+
+    return metavariableAssignment;
+  }
+}

package/src/assignment/variable.js

@@ -9,13 +9,24 @@ export default class VariableAssignment {
     return this.variable;
   }
 
-  assign(localContext) {
-    localContext.addVariable(this.variable);
+  assign(context) {
+    const variableAdded = context.addVariable(this.variable),
+          variableNode = this.variable.getNode(),
+          variableType = this.variable.getType(),
+          variableString = context.nodeAsString(variableNode),
+          variableTypeName = variableType.getName(),
+          variableAssigned = variableAdded; ///
+
+    variableAssigned ?
+      context.debug(`Able to assign the '${variableString}' variable with type '${variableTypeName}'.`, variableNode) :
+        context.trace(`Unable to assign the '${variableString}' variable with type '${variableTypeName}'.`, variableNode);
+
+    return variableAssigned;
   }
 
   static fromVariable(variable) {
-    const assignmentAssignment = new VariableAssignment(variable);
+    const variableAssignment = new VariableAssignment(variable);
 
-    return assignmentAssignment;
+    return variableAssignment;
   }
 }

package/src/constructor.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import Type from "./type";
-
 import { nodeAsString } from "./utilities/string";
+import { typeFromJSONAndFileContext } from "./type";
 import { termNodeFromConstructorDeclarationTokens } from "./utilities/node";
 import { constructorDeclarationTokensFromTermString } from "./utilities/tokens";
 
@@ -62,11 +61,7 @@ export default class Constructor {
 
       json = typeJSON;  ///
 
-      type = Type.fromJSONAndFileContext(json, fileContext);
-
-      const typeName = type.getName();
-
-      type = fileContext.findTypeByTypeName(typeName); ///
+      type = typeFromJSONAndFileContext(json, fileContext);
     }
 
     const tokens = constructorDeclarationTokens,  ///

package/src/context/file.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import Type from "../type";
 import Rule from "../rule";
 import Axiom from "../axiom";
 import Lemma from "../lemma";
@@ -11,9 +10,10 @@ import Combinator from "../combinator";
 import Constructor from "../constructor";
 import Metavariable from "../metavariable";
 
+import { push } from "../utilities/array";
 import { objectType } from "../type";
-import { push, filter } from "../utilities/array";
 import { statementMetaType } from "../metaType";
+import { typeFromJSONAndFileContext } from "../type";
 import { nodeAsString, nodesAsString } from "../utilities/string";
 
 const metaTypes = [
@@ -259,18 +259,15 @@ export default class FileContext {
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
-    types = [ ///
-      ...types,
-      objectType
-    ];
+    types.push(objectType);
 
     const type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+      const matches = type.matchTypeName(typeName);
 
-            if (matches) {
-              return true;
-            }
-          }) || null;
+      if (matches) {
+        return true;
+      }
+    }) || null;
 
     return type;
   }
@@ -331,13 +328,13 @@ export default class FileContext {
     return theorem;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
+            const nodeMatches = variable.matchNode(node);
 
-            if (matches) {
+            if (nodeMatches) {
               return true;
             }
           }) || null;
@@ -372,11 +369,11 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchName(name);
+            const matches = metavariable.matchNode(node);
 
             if (matches) {
               return true;
@@ -400,15 +397,15 @@ export default class FileContext {
     return typePresent;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
+  isVariablePresentByVariableNode(variableNode) {
+    const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
 
     return variablePresent;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -453,18 +450,24 @@ export default class FileContext {
   }
 
   addVariable(variable) {
-    const variableName = variable.getName();
+    let variableAdded = false;
 
-    filter(this.variables, (variable) => {
-      const name = variable.getName(),
-            nameVariableName = (name === variableName);
+    const node = variable.getNode(),
+          variablePresent = this.variables.some((variable) => {
+            const nodeMatches = variable.matchNode(node);
 
-      if (!nameVariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
 
-    this.variables.push(variable);
+    if (!variablePresent) {
+      this.variables.push(variable);
+
+      variableAdded = true;
+    }
+
+    return variableAdded;
   }
 
   addConjecture(conjecture) {
@@ -480,18 +483,24 @@ export default class FileContext {
   }
 
   addMetavariable(metavariable) {
-    const metavariableName = metavariable.getName();
+    let metavariableAdded = false;
 
-    filter(this.metavariables, (metavariable) => {
-      const name = metavariable.getName(),
-            nameMetavariableName = (name === metavariableName);
+    const node = metavariable.getNode(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const nodeMatches = metavariable.matchNode(node);
 
-      if (!nameMetavariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
 
-    this.metavariables.push(metavariable);
+    return metavariableAdded;
   }
 
   trace(message, node) { this.releaseContext.trace(message, node, this.tokens, this.filePath); }
@@ -620,7 +629,7 @@ export default class FileContext {
 
     typesJSON.forEach((typeJSON) => {
       const json = typeJSON,  ///
-            type = Type.fromJSONAndFileContext(json, fileContext);
+            type = typeFromJSONAndFileContext(json, fileContext);
 
       this.types.push(type);
     });