occam-verify-cli 0.0.548 → 0.0.550

package/src/verify/statement.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import Verifier from "../verifier";
-import Variable from "../variable";
 import Equality from "../equality";
-import Assignment from "../assignment";
 import verifyTerm from "../verify/term";
 import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
+import verifyTypeInference from "../verify/typeInference";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { objectType } from "../type";
@@ -21,6 +20,7 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
       metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      typeInferenceNodeQuery = nodeQuery("/statement/typeInference!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
@@ -33,6 +33,12 @@ export default function verifyStatement(statementNode, assignments, derived, con
     statementVerified = statementVerifiedAgainstCombinators;  ///
   }
 
+  if (!statementVerified) {
+    const statementVerifiedAsTypeInference = verifyStatementAsTypeInference(statementNode, derived, context);
+
+    statementVerified = statementVerifiedAsTypeInference; ///
+  }
+
   if (!statementVerified) {
     const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
 
@@ -40,7 +46,7 @@ export default function verifyStatement(statementNode, assignments, derived, con
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assignments, derived, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
@@ -163,7 +169,7 @@ class StatementVerifier extends Verifier {
 
 const statementVerifier = new StatementVerifier();
 
-function verifyStatementAgainstCombinators(statementNode, context) {
+export function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
   let combinators = context.getCombinators();
@@ -188,7 +194,7 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode,  ///
         nonTerminalNodeB = combinatorStatementNode, ///
@@ -198,6 +204,26 @@ function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   return statementVerifiedAgainstCombinator;
 }
 
+function verifyStatementAsTypeInference(statementNode, derived, context) {
+  let statementVerifiedAsTypeInference = false;
+
+  const typeInferenceNode = typeInferenceNodeQuery(statementNode);
+
+  if (typeInferenceNode !== null) {
+    if (!derived) {
+      const typeInferenceString = context.nodeAsString(typeInferenceNode);
+
+      context.error(`The '${typeInferenceString}' type inference can only be derived.`, typeInferenceNode);
+    } else {
+      const typeInferenceVerified = verifyTypeInference(typeInferenceNode, context);
+
+      statementVerifiedAsTypeInference = typeInferenceVerified; ///
+    }
+  }
+
+  return statementVerifiedAsTypeInference;
+}
+
 function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
@@ -212,7 +238,7 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, assignments, derived, context) {
+function verifyStatementAsEquality(statementNode, derived, context) {
   let statementVerifiedAsEquality = false;
 
   const combinator = equalityCombinator,  ///
@@ -250,27 +276,6 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to, a sub-type of or a super-type of the right '${rightVariableName}' variable's '${rightVariableTypeName}' type.`, statementNode);
         } else {
-          const leftVariableTypeSuperTypeOfRightVariableType = leftVariableType.isSuperTypeOf(rightVariableType),
-                rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
-
-          if (leftVariableTypeSuperTypeOfRightVariableType) {
-            const name = leftVariableName, ///
-                  type = rightVariableType,  ///
-                  variable = Variable.fromNameAndType(name, type),
-                  assignment = Assignment.fromVariable(variable);
-
-            assignments.push(assignment);
-          }
-
-          if (rightVariableTypeSuperTypeOfLeftVariableType) {
-            const name = rightVariableName, ///
-                  type = leftVariableType,  ///
-                  variable = Variable.fromNameAndType(name, type),
-                  assignment = Assignment.fromVariable(variable);
-
-            assignments.push(assignment);
-          }
-
           statementVerifiedAsEquality = true;
         }
       } else if (leftTermVerifiedAsVariable) {
@@ -293,13 +298,6 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           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 name = leftVariableName,  ///
-                type = rightTermType, ///
-                variable = Variable.fromNameAndType(name, type),
-                assignment = Assignment.fromVariable(variable);
-
-          assignments.push(assignment);
-
           statementVerifiedAsEquality = true;
         }
       } else if (rightTermVerifiedAsVariable) {
@@ -322,13 +320,6 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
         } else {
-          const name = rightVariableName,  ///
-                type = leftTermType, ///
-                variable = Variable.fromNameAndType(name, type),
-                assignment = Assignment.fromVariable(variable);
-
-          assignments.push(assignment);
-
           statementVerifiedAsEquality = true;
         }
       } else {

package/src/verify/typeInference.js

@@ -0,0 +1,146 @@
+"use strict";
+
+import verifyTerm from "./term";
+import equalityCombinator from "../ocmbinator/equality";
+
+import { nodeQuery } from "../utilities/query";
+import { first, second } from "../utilities/array";
+import { verifyTermAsVariable } from "./term";
+import { verifyVariableTypeAssertion } from "./assertion/type";
+import { verifyStatementAgainstCombinator } from "../verify/statement";
+import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
+
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
+      statementNodeQuery = nodeQuery("/typeInference/statement!"),
+      typeAssertionNodeQuery = nodeQuery("/typeInference/typeAssertion!");
+
+export default function verifyTypeInference(typeInferenceNode, context) {
+  let typeInferenceVerified = false;
+
+  const typeInferenceString = context.nodeAsString(typeInferenceNode);
+
+  context.debug(`Verifying the '${typeInferenceString}' type inference...`, typeInferenceNode);
+
+  let statementNode = statementNodeQuery(typeInferenceNode);
+
+  const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
+
+  if (bracketedStatementChildNode !== null) {
+    statementNode = bracketedStatementChildNode; ///
+  }
+
+  const statementString = context.nodeAsString(statementNode),
+        statementMatches = context.matchStatement(statementNode);
+
+  if (!statementMatches) {
+    context.error(`The '${statementString}' statement is not present in the context.`, typeInferenceNode);
+  } else {
+    const combinator = equalityCombinator,  ///
+          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+
+    if (!statementVerifiedAgainstCombinator) {
+      context.error(`The '${statementString}' statement is not an equality.`, typeInferenceNode);
+    } else {
+      const derived = false,  ///
+            assignments = [],
+            typeAssertionNode = typeAssertionNodeQuery(typeInferenceNode),
+            variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context)
+
+      if (variableTypeAssertionVerified) {
+        const firstAssignment = first(assignments),
+              assignment = firstAssignment, ///
+              variables = [],
+              leftTermNode = leftTermNodeQuery(statementNode),
+              rightTermNode = rightTermNodeQuery(statementNode),
+              leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
+              rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
+
+        if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
+          const firstVariable = first(variables),
+                secondVariable = second(variables),
+                leftVariable = firstVariable, ///
+                rightVariable = secondVariable, ///
+                leftVariableName = leftVariable.getName(),
+                leftVariableType = leftVariable.getType(),
+                rightVariableName = rightVariable.getName(),
+                rightVariableType = rightVariable.getType(),
+                leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
+
+          if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
+            const leftVariableTypeSuperTypeOfRightVariableType = leftVariableType.isSuperTypeOf(rightVariableType),
+                  rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
+
+            if (leftVariableTypeSuperTypeOfRightVariableType) {
+              const name = leftVariableName, ///
+                    type = rightVariableType;  ///
+
+              assignAssignment(name, type, assignment, context);
+            }
+
+            if (rightVariableTypeSuperTypeOfLeftVariableType) {
+              const name = rightVariableName, ///
+                    type = leftVariableType;  ///
+
+              assignAssignment(name, type, assignment, context);
+            }
+          }
+        } else if (leftTermVerifiedAsVariable) {
+          const types = [];
+
+          verifyTerm(rightTermNode, types, context);
+
+          const firstType = first(types),
+                firstVariable = first(variables),
+                leftVariable = firstVariable, ///
+                rightTermType = firstType,  ///
+                leftVariableName = leftVariable.getName(),
+                leftVariableType = leftVariable.getType(),
+                leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
+
+          if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
+            const name = leftVariableName,  ///
+                  type = rightTermType; ///
+
+            assignAssignment(name, type, assignment, context);
+          }
+        } else if (rightTermVerifiedAsVariable) {
+          const types = [];
+
+          verifyTerm(leftTermNode, types, context);
+
+          const firstType = first(types),
+                firstVariable = first(variables),
+                leftTermType = firstType,  ///
+                rightVariable = firstVariable, ///
+                rightVariableName = rightVariable.getName(),
+                rightVariableType = rightVariable.getType(),
+                rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
+
+          if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
+            const name = rightVariableName,  ///
+                  type = leftTermType; ///
+
+            assignAssignment(name, type, assignment, context);
+          }
+        }
+
+        typeInferenceVerified = true;
+      }
+    }
+  }
+
+  if (typeInferenceVerified) {
+    context.info(`Verified the '${typeInferenceString}' type inference.`, typeInferenceNode);
+  }
+
+  return typeInferenceVerified;
+}
+
+function assignAssignment(name, type, assignment, context) {
+  const assignmentMatchesNameAndType = assignment.matchNameAndType(name, type);
+
+  if (assignmentMatchesNameAndType) {
+    assignment.assign(context);
+  }
+}