occam-verify-cli 0.0.531 → 0.0.533

package/src/verify/statement.js

@@ -1,19 +1,25 @@
 "use strict";
 
-import Equality from "../equality";
+import Variable from "../variable";
+import Assertion from "../assertion";
 import verifyTerm from "../verify/term";
+import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
 import { objectType } from "../type";
+import { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
+import { verifyTermAsVariable } from "../verify/term";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
+      leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
       metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
@@ -35,7 +41,7 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assertions, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -43,16 +49,6 @@ export default function verifyStatement(statementNode, assertions, derived, cont
   return statementVerified;
 }
 
-export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
-  const combinatorStatementNode = combinator.getStatementNode(),
-        node = statementNode,  ///
-        combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, context),
-        statementVerifiedAgainstCombinator = nodeVerified;  ///
-
-  return statementVerifiedAgainstCombinator;
-}
-
 function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
@@ -78,6 +74,16 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   return statementVerifiedAgainstCombinators;
 }
 
+function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+      node = statementNode,  ///
+      combinatorNode = combinatorStatementNode, ///
+      nodeVerified = verifyNode(node, combinatorNode, context),
+      statementVerifiedAgainstCombinator = nodeVerified;  ///
+
+  return statementVerifiedAgainstCombinator;
+}
+
 function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
@@ -92,25 +98,73 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, derived, cont
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
+function verifyStatementAsEquality(statementNode, assertions, derived, context) {
   let statementVerifiedAsEquality = false;
 
-  const equality = Equality.fromStatementNode(statementNode, context);
+  const statementString = context.nodeAsString(statementNode);
 
-  if (equality !== null) {
-    statementVerifiedAsEquality = true; ///
+  const combinator = equalityCombinator,  ///
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
+  if (statementVerifiedAgainstCombinator) {
     if (derived) {
-      const equalities = context.getEqualities();
-
-      if (equalities !== null) {
-        const equalityEquates = equality.equate(equalities, context);
-
-        statementVerifiedAsEquality = equalityEquates; ///
+      debugger
+    } else {
+      const types = [],
+            variables = [],
+            leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode),
+            leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context);
+
+      if (leftTermVerifiedAsVariable) {
+        verifyTerm(rightTermNode, types, context);
+
+        const firstVariable = first(variables),
+              leftVariable = firstVariable, ///
+              firstType = first(types),
+              rightTermType = firstType, ///
+              leftVariableType = leftVariable.getType(),
+              leftVariableName = leftVariable.getName(),
+              leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
+
+        if (!leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
+          const rightTermString = nodeAsString(rightTermNode),
+                rightTermTypeName = rightTermType.getName(),
+                leftVariableTypeName = leftVariableType.getName();
+
+          context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
+        } else {
+          const type = leftVariableType,  ///
+                name = leftVariableName,  ///
+                termNode = rightTermNode, ///
+                variable = Variable.fromTypeNameAndTermNode(type, name, termNode),
+                assertion = Assertion.fromVariable(variable);
+
+          assertions.push(assertion);
+
+          statementVerifiedAsEquality = true;
+        }
+      } else {
+        const rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+        if (rightTermVerifiedAsVariable) {
+          const firstVariable = first(variables),
+                rightVariable = firstVariable,  ///
+                leftTermString = nodeAsString(leftTermNode),
+                rightVariableName = rightVariable.getName();
+
+          context.error(`The left '${leftTermString}' term cannot be equated with the right '${rightVariableName}' variable.`, statementNode);
+        } else {
+          statementVerifiedAsEquality = true;
+        }
       }
     }
   }
 
+  if (statementVerifiedAsEquality) {
+    context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
+  }
+
   return statementVerifiedAsEquality;
 }
 

package/lib/assertion/type.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return TypeAssertion;
-    }
-});
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var TypeAssertion = /*#__PURE__*/ function() {
-    function TypeAssertion(variable) {
-        _classCallCheck(this, TypeAssertion);
-        this.variable = variable;
-    }
-    _createClass(TypeAssertion, [
-        {
-            key: "getVariable",
-            value: function getVariable() {
-                return this.variable;
-            }
-        },
-        {
-            key: "assert",
-            value: function assert(proofContext) {
-                proofContext.addVariable(this.variable);
-            }
-        }
-    ], [
-        {
-            key: "fromVariable",
-            value: function fromVariable(variable) {
-                var typeAssertion = new TypeAssertion(variable);
-                return typeAssertion;
-            }
-        }
-    ]);
-    return TypeAssertion;
-}();
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hc3NlcnRpb24vdHlwZS5qcyIsIjw8anN4LWNvbmZpZy1wcmFnbWEuanM+PiJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgVHlwZUFzc2VydGlvbiB7XG4gIGNvbnN0cnVjdG9yKHZhcmlhYmxlKSB7XG4gICAgdGhpcy52YXJpYWJsZSA9IHZhcmlhYmxlO1xuICB9XG5cbiAgZ2V0VmFyaWFibGUoKSB7XG4gICAgcmV0dXJuIHRoaXMudmFyaWFibGU7XG4gIH1cblxuICBhc3NlcnQocHJvb2ZDb250ZXh0KSB7XG4gICAgcHJvb2ZDb250ZXh0LmFkZFZhcmlhYmxlKHRoaXMudmFyaWFibGUpO1xuICB9XG5cbiAgc3RhdGljIGZyb21WYXJpYWJsZSh2YXJpYWJsZSkge1xuICAgIGNvbnN0IHR5cGVBc3NlcnRpb24gPSBuZXcgVHlwZUFzc2VydGlvbih2YXJpYWJsZSk7XG5cbiAgICByZXR1cm4gdHlwZUFzc2VydGlvbjtcbiAgfVxufVxuIiwiUmVhY3QuY3JlYXRlRWxlbWVudCJdLCJuYW1lcyI6WyJUeXBlQXNzZXJ0aW9uIiwidmFyaWFibGUiLCJnZXRWYXJpYWJsZSIsImFzc2VydCIsInByb29mQ29udGV4dCIsImFkZFZhcmlhYmxlIiwiZnJvbVZhcmlhYmxlIiwidHlwZUFzc2VydGlvbiJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7ZUFFcUJBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQU4sSUFBQSxBQUFNQSw4QkFBTjthQUFNQSxjQUNQQyxRQUFROzhCQURERDtRQUVqQixJQUFJLENBQUNDLFFBQVEsR0FBR0E7O2lCQUZDRDs7WUFLbkJFLEtBQUFBO21CQUFBQSxTQUFBQSxjQUFjO2dCQUNaLE9BQU8sSUFBSSxDQUFDRCxRQUFRO1lBQ3RCOzs7WUFFQUUsS0FBQUE7bUJBQUFBLFNBQUFBLE9BQU9DLFlBQVksRUFBRTtnQkFDbkJBLGFBQWFDLFdBQVcsQ0FBQyxJQUFJLENBQUNKLFFBQVE7WUFDeEM7Ozs7WUFFT0ssS0FBQUE7bUJBQVAsU0FBT0EsYUFBYUwsUUFBUSxFQUFFO2dCQUM1QixJQUFNTSxnQkFBZ0IsSUFkTFAsY0FjdUJDO2dCQUV4QyxPQUFPTTtZQUNUOzs7V0FqQm1CUCJ9

package/lib/node/statement/equality.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _node = require("../../utilities/node");
-var equalityStatementString = "n=m";
-var equalityStatementNode = (0, _node.statementNodeFromStatementString)(equalityStatementString);
-var _default = equalityStatementNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ub2RlL3N0YXRlbWVudC9lcXVhbGl0eS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgc3RhdGVtZW50Tm9kZUZyb21TdGF0ZW1lbnRTdHJpbmcgfSBmcm9tIFwiLi4vLi4vdXRpbGl0aWVzL25vZGVcIjtcblxuY29uc3QgZXF1YWxpdHlTdGF0ZW1lbnRTdHJpbmcgPSBcIm49bVwiO1xuXG5jb25zdCBlcXVhbGl0eVN0YXRlbWVudE5vZGUgPSBzdGF0ZW1lbnROb2RlRnJvbVN0YXRlbWVudFN0cmluZyhlcXVhbGl0eVN0YXRlbWVudFN0cmluZyk7XG5cbmV4cG9ydCBkZWZhdWx0IGVxdWFsaXR5U3RhdGVtZW50Tm9kZTtcblxuIl0sIm5hbWVzIjpbImVxdWFsaXR5U3RhdGVtZW50U3RyaW5nIiwiZXF1YWxpdHlTdGF0ZW1lbnROb2RlIiwic3RhdGVtZW50Tm9kZUZyb21TdGF0ZW1lbnRTdHJpbmciXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQVFBOzs7ZUFBQTs7O29CQU5pRDtBQUVqRCxJQUFNQSwwQkFBMEI7QUFFaEMsSUFBTUMsd0JBQXdCQyxJQUFBQSxzQ0FBZ0MsRUFBQ0Y7SUFFL0QsV0FBZUMifQ==

package/src/node/statement/equality.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import { statementNodeFromStatementString } from "../../utilities/node";
-
-const equalityStatementString = "n=m";
-
-const equalityStatementNode = statementNodeFromStatementString(equalityStatementString);
-
-export default equalityStatementNode;
-