occam-verify-cli 0.0.679 → 0.0.680

package/src/verify/assertion/type.js

@@ -1,169 +0,0 @@
-"use strict";
-
-import Variable from "../../variable";
-import Assignment from "../../assignment";
-
-import { first } from "../../utilities/array";
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
-
-const termNodeQuery = nodeQuery("/typeAssertion/term!"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type!");
-
-export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
-  let typeAssertionVerified = false;
-
-  const typeAssertionString = context.nodeAsString(typeAssertionNode);
-
-  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
-
-  const typeNode = typeNodeQuery(typeAssertionNode),
-        typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    context.info(`The '${typeName}' type is not present.`, typeAssertionNode);
-  } else {
-    if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);
-
-      typeAssertionVerified = variableTypeAssertionVerified;  ///
-    }
-
-    if (!typeAssertionVerified) {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, derived, context);
-
-      typeAssertionVerified = termTypeAssertionVerified;  ///
-    }
-  }
-
-  if (typeAssertionVerified) {
-    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
-  }
-
-  return typeAssertionVerified;
-}
-
-export function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {
-  let variableTypeAssertionVerified = false;
-
-  const variables = [],
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
-
-  if (termVerifiedAsVariable) {
-    const typeAssertionString = context.nodeAsString(typeAssertionNode);
-
-    context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);
-
-    const typeNode = typeNodeQuery(typeAssertionNode),
-          typeName = typeNameFromTypeNode(typeNode),
-          assertedTypeName = typeName,  ///
-          assertedType = context.findTypeByTypeName(assertedTypeName);
-
-    if (assertedType === null) {
-      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
-    } else {
-      const firstVariable = first(variables),
-            variable = firstVariable, ///
-            variableName = variable.getName(),
-            variableType = variable.getType();
-
-      if (derived) {
-        const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
-
-        if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
-          const assertedTypeName = assertedType.getName(),
-                variableTypeName = variableType.getName();
-
-          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-        } else {
-          variableTypeAssertionVerified = true;
-        }
-      } else {
-        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
-
-        if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-          const assertedTypeName = assertedType.getName(),
-                variableTypeName = variableType.getName();
-
-          context.info(`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),
-                assignment = Assignment.fromVariable(variable);
-
-          assignments.push(assignment);
-
-          variableTypeAssertionVerified = true;
-        }
-      }
-    }
-
-    if (variableTypeAssertionVerified) {
-      context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);
-    }
-  }
-
-  return variableTypeAssertionVerified;
-}
-
-function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
-  let termTypeAssertionVerified = false;
-
-  const types = [],
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-
-  if (termVerifiedAgainstConstructors) {
-    const typeAssertionString = context.nodeAsString(typeAssertionNode);
-
-    context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);
-
-    const typeNode = typeNodeQuery(typeAssertionNode),
-          typeName = typeNameFromTypeNode(typeNode),
-          assertedTypeName = typeName,  ///
-          assertedType = context.findTypeByTypeName(assertedTypeName);
-
-    if (assertedType === null) {
-      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
-    } else {
-      const firstType = first(types),
-            termType = firstType; ///
-
-      if (derived) {
-        const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
-
-        if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
-          const termString = context.nodeAsString(termNode),
-                termTypeName = termType.getName(),
-                assertedTypeName = assertedType.getName();
-
-          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
-        } else {
-          termTypeAssertionVerified = true;
-        }
-      } else {
-        const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
-
-        if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
-          const termString = context.nodeAsString(termNode),
-                termTypeName = termType.getName(),
-                assertedTypeName = assertedType.getName();
-
-          context.info(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
-        } else {
-          termTypeAssertionVerified = true;
-        }
-      }
-    }
-
-    if (termTypeAssertionVerified) {
-      context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);
-    }
-  }
-
-  return termTypeAssertionVerified;
-}
-

package/src/verify/typeInference.js

@@ -1,146 +0,0 @@
-"use strict";
-
-import Equality from "../equality";
-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 statementNodeQuery = nodeQuery("/typeInference/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/typeInference/typeAssertion!");
-
-export default function verifyTypeInference(typeInferenceNode, context) {
-  let typeInferenceVerified = false;
-
-  const typeInferenceString = context.nodeAsString(typeInferenceNode);
-
-  context.trace(`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.info(`The '${statementString}' statement is not present in the context.`, typeInferenceNode);
-  } else {
-    const combinator = equalityCombinator,  ///
-          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
-
-    if (!statementVerifiedAgainstCombinator) {
-      context.info(`The '${statementString}' statement is not an equality.`, typeInferenceNode);
-    } else {
-      const derived = false,  ///
-            equality = Equality.fromStatementNode(statementNode),
-            assignments = [],
-            typeAssertionNode = typeAssertionNodeQuery(typeInferenceNode),
-            variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context)
-
-      if (variableTypeAssertionVerified) {
-        const firstAssignment = first(assignments),
-              assignment = firstAssignment, ///
-              variables = [],
-              leftTermNode = equality.getLeftTermNode(),
-              rightTermNode = equality.getRightTermNode(),
-              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.debug(`...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);
-  }
-}