occam-verify-cli 0.0.492 → 0.0.495

package/lib/verify/statementTypeAssertion.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyStatementTypeAssertion;
-    }
-});
-var _variable = /*#__PURE__*/ _interopRequireDefault(require("../variable"));
-var _array = require("../utilities/array");
-var _string = require("../utilities/string");
-var _query = require("../utilities/query");
-var _term = require("../verify/term");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type"), typeAssertionNodeQuery = (0, _query.nodeQuery)("/statement/typeAssertion!");
-function verifyStatementTypeAssertion(statementNode, qualified, proofContext) {
-    var statementTypeAssertionVerified = false;
-    proofContext.begin(statementNode);
-    var statementString = (0, _string.nodeAsString)(statementNode);
-    proofContext.debug("Verifying the '".concat(statementString, "' statement type assertion..."));
-    var typeAssertionNode = typeAssertionNodeQuery(statementNode);
-    if (typeAssertionNode !== null) {
-        var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), typePresent = proofContext.isTypePresentByTypeName(typeName);
-        if (!typePresent) {
-            proofContext.error("The ".concat(typeName, " type is not present."));
-        } else {
-            if (!statementTypeAssertionVerified) {
-                var variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);
-                statementTypeAssertionVerified = variableTypeAssertionVerified; ///
-            }
-            if (!statementTypeAssertionVerified) {
-                var termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);
-                statementTypeAssertionVerified = termTypeAssertionVerified; ///
-            }
-        }
-    }
-    if (statementTypeAssertionVerified) {
-        proofContext.info("Verified the '".concat(statementString, "' statement type assertion."));
-    }
-    statementTypeAssertionVerified ? proofContext.complete(statementNode) : proofContext.halt(statementNode);
-    return statementTypeAssertionVerified;
-}
-function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext) {
-    var variableTypeAssertionVerified = false;
-    var context = proofContext, variables = [], termNode = termNodeQuery(typeAssertionNode), termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
-    if (termVerifiedAsVariable) {
-        var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstVariable = (0, _array.first)(variables), variable = firstVariable, variableName = variable.getName(), variableType = variable.getType();
-        var assertedTypeEqualToOrSubTypeOfVariableType = variableType === null ? true : assertedType.isEqualToOrSubTypeOf(variableType);
-        if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-            proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(variableName, "' variable type."));
-        } else {
-            if (!qualified) {
-                var type = assertedType, name = variableName, variable1 = _variable.default.fromTypeAndName(type, name);
-                proofContext.addVariable(variable1);
-            }
-            variableTypeAssertionVerified = true;
-        }
-    }
-    return variableTypeAssertionVerified;
-}
-function verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext) {
-    var termTypeAssertionVerified = false;
-    var types = [], context = proofContext, termNode = termNodeQuery(typeAssertionNode), termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context);
-    if (termVerifiedAgainstConstructors) {
-        var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstType = (0, _array.first)(types), termType = firstType, termString = (0, _string.nodeAsString)(termNode), assertedTypeEqualToOrSubTypeOfTermType = termType === null ? true : assertedType.isEqualToOrSubTypeOf(termType);
-        if (!assertedTypeEqualToOrSubTypeOfTermType) {
-            proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(termString, "' term type."));
-        } else {
-            if (!qualified) {
-                debugger;
-            }
-            termTypeAssertionVerified = true;
-        }
-    }
-    return termTypeAssertionVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/statementTypeAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../variable\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../verify/term\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\"),\n      typeAssertionNodeQuery = nodeQuery(\"/statement/typeAssertion!\");\n\nexport default function verifyStatementTypeAssertion(statementNode, qualified, proofContext) {\n  let statementTypeAssertionVerified = false;\n\n  proofContext.begin(statementNode);\n\n  const statementString = nodeAsString(statementNode);\n\n  proofContext.debug(`Verifying the '${statementString}' statement type assertion...`);\n\n  const typeAssertionNode = typeAssertionNodeQuery(statementNode);\n\n  if (typeAssertionNode !== null) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          typePresent = proofContext.isTypePresentByTypeName(typeName);\n\n    if (!typePresent) {\n      proofContext.error(`The ${typeName} type is not present.`);\n    } else {\n      if (!statementTypeAssertionVerified) {\n        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);\n\n        statementTypeAssertionVerified = variableTypeAssertionVerified;  ///\n      }\n\n      if (!statementTypeAssertionVerified) {\n        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);\n\n        statementTypeAssertionVerified = termTypeAssertionVerified;  ///\n      }\n    }\n  }\n\n  if (statementTypeAssertionVerified) {\n    proofContext.info(`Verified the '${statementString}' statement type assertion.`);\n  }\n\n  statementTypeAssertionVerified ?\n    proofContext.complete(statementNode) :\n      proofContext.halt(statementNode);\n\n  return statementTypeAssertionVerified;\n}\n\nfunction verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext) {\n  let variableTypeAssertionVerified = false;\n\n  const context = proofContext, ///\n        variables = [],\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n  if (termVerifiedAsVariable) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n          firstVariable = first(variables),\n          variable = firstVariable, ///\n          variableName = variable.getName(),\n          variableType = variable.getType();\n\n    const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?\n                                                         true : ///\n                                                           assertedType.isEqualToOrSubTypeOf(variableType);\n\n    if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n      proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);\n    } else {\n      if (!qualified) {\n        const type = assertedType,  ///\n              name = variableName,  ///\n              variable = Variable.fromTypeAndName(type, name);\n\n        proofContext.addVariable(variable);\n      }\n\n      variableTypeAssertionVerified = true;\n    }\n  }\n\n  return variableTypeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext) {\n  let termTypeAssertionVerified = false;\n\n  const types = [],\n        context = proofContext, ///\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n  if (termVerifiedAgainstConstructors) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n          firstType = first(types),\n          termType = firstType,\n          termString = nodeAsString(termNode),\n          assertedTypeEqualToOrSubTypeOfTermType = (termType === null) ?\n                                                     true : ///\n                                                       assertedType.isEqualToOrSubTypeOf(termType);\n\n    if (!assertedTypeEqualToOrSubTypeOfTermType) {\n      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);\n    } else {\n      if (!qualified) {\n        debugger\n      }\n\n      termTypeAssertionVerified = true;\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\n"],"names":["verifyStatementTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNodeQuery","statementNode","qualified","proofContext","statementTypeAssertionVerified","begin","statementString","nodeAsString","debug","typeAssertionNode","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","error","variableTypeAssertionVerified","verifyVariableTypeAssertion","termTypeAssertionVerified","verifyTermTypeAssertion","info","complete","halt","context","variables","termNode","termVerifiedAsVariable","verifyTermAsVariable","assertedTypeName","assertedType","findTypeByTypeName","firstVariable","first","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSubTypeOfVariableType","isEqualToOrSubTypeOf","type","name","Variable","fromTypeAndName","addVariable","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","firstType","termType","termString","assertedTypeEqualToOrSubTypeOfTermType"],"mappings":"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"}

package/src/equality.js

@@ -1,231 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "./utilities/query";
-import { TERM_RULE_NAME } from "./ruleNames";
-import { EQUALS_CHARACTER } from "./constants";
-
-const specialNodeQuery = nodeQuery("/statement/@special!"),
-      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
-      rightTermNodeQuery = nodeQuery("/statement/term[1]");
-
-export default class Equality {
-  constructor(leftTermNode, rightTermNode) {
-    this.leftTermNode = leftTermNode;
-    this.rightTermNode = rightTermNode;
-  }
-
-  getLeftTermNode() {
-    return this.leftTermNode;
-  }
-
-  getRightTermNode() {
-    return this.rightTermNode;
-  }
-
-  match(equality, equalities, proofContext) {
-    let matches = false;
-
-    const leftTermNode = equality.getLeftTermNode(),
-          rightTermNode = equality.getRightTermNode();
-
-    if (!matches) {
-      const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    if (!matches) {
-      const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    return matches;
-  }
-
-  matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext) {
-    let leftTermNodeAndRightTermNodeMatch = true;
-
-    if (leftTermNodeAndRightTermNodeMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.rightTermNode :
-                                      this.leftTermNode,  ///
-            rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext);
-
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
-    }
-
-    if (leftTermNodeAndRightTermNodeMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.leftTermNode :
-                                      this.rightTermNode,  ///
-            rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext);
-
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
-    }
-
-    return leftTermNodeAndRightTermNodeMatch;
-  }
-
-  equate(equalities, proofContext) {
-    const leftNonTerminalNode = this.leftTermNode,  ///
-          rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext),
-          equates = nonTerminalNodeEquates; ///
-
-    return equates;
-  }
-
-  static fromProofStep(proofStep) {
-    let equality = null;
-
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const specialNode = specialNodeQuery(statementNode);
-
-      if (specialNode !== null) {
-        const terminalNode = specialNode, ///
-              terminalNodeContent = terminalNode.getContent();
-
-        if (terminalNodeContent === EQUALS_CHARACTER) {
-          const leftTermNode = leftTermNodeQuery(statementNode),
-                rightTermNode = rightTermNodeQuery(statementNode);
-
-          equality = new Equality(leftTermNode, rightTermNode);
-        }
-      }
-    }
-
-    return equality;
-  }
-
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-}
-
-function equateNode(nodeA, nodeB, equalities, proofContext) {
-  let nodeEquates = false;
-
-  const nodeATerminalNode = nodeA.isTerminalNode(),
-        nodeBTerminalNode = nodeB.isTerminalNode();
-
-  if (nodeATerminalNode === nodeBTerminalNode) {
-    if (nodeATerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities, proofContext);
-
-      nodeEquates = terminalNodeEquates;  ///
-    } else {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities, proofContext);
-
-      nodeEquates = nonTerminalNodeEquates; ///
-    }
-  }
-
-  return nodeEquates;
-}
-
-function equateNodes(leftNodes, rightNodes, equalities, proofContext) {
-  let nodesEquate = false;
-
-  const leftNodesLength = leftNodes.length,
-        rightNodesLength = rightNodes.length;
-
-  if (leftNodesLength === rightNodesLength) {
-    nodesEquate = leftNodes.every((LeftNode, index) => {
-      const rightNode = rightNodes[index],
-            nodeEquates = equateNode(LeftNode, rightNode, equalities, proofContext);
-
-      if (nodeEquates) {
-        return true;
-      }
-    });
-  }
-
-  return nodesEquate;
-}
-
-function equateTerminalNode(terminalNodeA, terminalNodeB, equalities, proofContext) {
-  const matches = terminalNodeA.match(terminalNodeB),
-        terminalNodeEquates = matches;  ///
-
-  return terminalNodeEquates;
-}
-
-function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext) {
-  let nonTerminalNodeEquates = false;
-
-  const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
-        rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
-
-  if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
-    const ruleName = leftNonTerminalNodeRuleName, ///
-          ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
-
-    if (ruleNameTermRuleName) {
-      const leftTermNode = leftNonTerminalNode, ///
-            rightTermNode = rightNonTerminalNode, ///
-            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities, proofContext);
-
-      nonTerminalNodeEquates = termNodeEquates;  ///
-    }
-
-    if (!nonTerminalNodeEquates) {
-      const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-            rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-            leftNodes = leftNonTerminalNodeChildNodes, ///
-            rightNodes = rightNonTerminalNodeChildNodes, ///
-            nodesEquate = equateNodes(leftNodes, rightNodes, equalities, proofContext);
-
-      nonTerminalNodeEquates = nodesEquate; ///
-    }
-  }
-
-  return nonTerminalNodeEquates;
-}
-
-function equateTermNode(leftTermNode, rightTermNode, equalities, proofContext) {
-  const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-        equalityA = equality, ///
-        equalityMatches = equalities.some((equality) => { ///
-          let equalitiesB = equalities; ///
-
-          const equalityB = equality; ///
-
-          equalitiesB = pruneEqualities(equalitiesB, equalityB);  ///
-
-          const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, proofContext);
-
-          if (equalityAMatchesEqualityB) {
-            return true;
-          }
-        }),
-        termNodeEquates = equalityMatches;  ///
-
-  return termNodeEquates;
-}
-
-function pruneEqualities(equalities, equality) {
-  const equalityA = equality; ///
-
-  equalities = equalities.filter((equality) => {
-    const equalityB = equality; ///
-
-    if (equalityA !== equalityB) {
-      return true;
-    }
-  });
-
-  return equalities;
-}

package/src/verify/statementAsEquality.js

@@ -1,101 +0,0 @@
-"use strict";
-
-import Equality from "../equality";
-import verifyTerm from "../verify/term";
-
-import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
-import { first, second } from "../utilities/array";
-import { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from "../constants";
-
-const specialNodeQuery = nodeQuery("/statement/@special!"),
-      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
-      rightTermNodeQuery = nodeQuery("/statement/term[1]");
-
-export default function verifyStatementAsEquality(statementNode, qualified, proofContext) {
-  let statementVerifiedAsEquality = false;
-
-  proofContext.begin(statementNode);
-
-  const statementString = nodeAsString(statementNode);
-
-  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);
-
-  const specialNode = specialNodeQuery(statementNode);
-
-  if (specialNode !== null) {
-    const terminalNode = specialNode, ///
-          terminalNodeContent = terminalNode.getContent();
-
-    if (terminalNodeContent === EQUALS_CHARACTER) {
-      const types = [],
-            context = proofContext,  ///
-            leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode),
-            leftTermVerified = verifyTerm(leftTermNode, types, context),
-            rightTermVerified = verifyTerm(rightTermNode, types, context);
-
-      if (leftTermVerified && rightTermVerified) {
-        const firstType = first(types),
-              secondType = second(types),
-              leftType = firstType, ///
-              rightType = secondType, ///
-              leftTermString = nodeAsString(leftTermNode),
-              rightTermString = nodeAsString(rightTermNode);
-
-        if ((leftType === null) && (rightType === null)) {
-          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
-        } else if (rightType === null) {
-          proofContext.info(`The type of the right '${rightTermString}' term is undefined and therefore the types cannot be equated.`);
-        } else if (leftType === null) {
-          proofContext.info(`The type of the left '${leftTermString}' term is undefined and therefore the types cannot be equated.`);
-        } else {
-          const leftTypeMatchesRightType = leftType.match(rightType);
-
-          if (!leftTypeMatchesRightType) {
-            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
-          } else {
-            if (!qualified) {
-              statementVerifiedAsEquality = true;
-            } else {
-              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-                    proofSteps = proofContext.getProofSteps(),
-                    equalities = equalitiesFromProofSteps(proofSteps),
-                    equalityEquates = equality.equate(equalities, proofContext);
-
-              statementVerifiedAsEquality = equalityEquates;  ///
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (statementVerifiedAsEquality) {
-    proofContext.info(`Verified the '${statementString}' equality.`);
-  }
-
-  statementVerifiedAsEquality ?
-    proofContext.complete(statementNode) :
-      proofContext.halt(statementNode);
-
-  return statementVerifiedAsEquality;
-}
-
-function equalitiesFromProofSteps(proofSteps) {
-  const start = -MAXIMUM_INDEXES_LENGTH;  ///
-
-  proofSteps = proofSteps.slice(start); ///
-
-  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
-    const equality = Equality.fromProofStep(proofStep);
-
-    if (equality !== null) {
-      equalities.push(equality);
-    }
-
-    return equalities;
-  }, []);
-
-  return equalities;
-}