occam-verify-cli 0.0.478 → 0.0.480

package/lib/verify/statementAsEquality.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyStatementAsEquality;
+    }
+});
+var _equality = /*#__PURE__*/ _interopRequireDefault(require("../equality"));
+var _variable = /*#__PURE__*/ _interopRequireDefault(require("../variable"));
+var _term = /*#__PURE__*/ _interopRequireWildcard(require("../verify/term"));
+var _query = require("../utilities/query");
+var _string = require("../utilities/string");
+var _array = require("../utilities/array");
+var _constants = require("../constants");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var specialNodeQuery = (0, _query.nodeQuery)("/statement/@special!"), leftTermNodeQuery = (0, _query.nodeQuery)("/statement/term[0]"), rightTermNodeQuery = (0, _query.nodeQuery)("/statement/term[1]");
+function verifyStatementAsEquality(statementNode, proofContext) {
+    var statementVerifiedAsEquality = false;
+    proofContext.begin(statementNode);
+    var statementString = (0, _string.nodeAsString)(statementNode);
+    proofContext.debug("Verifying the '".concat(statementString, "' statement as an equality..."));
+    var specialNode = specialNodeQuery(statementNode);
+    if (specialNode !== null) {
+        var terminalNode = specialNode, terminalNodeContent = terminalNode.getContent();
+        if (terminalNodeContent === _constants.EQUALS_CHARACTER) {
+            var types = [], context = proofContext, leftTermNode = leftTermNodeQuery(statementNode), rightTermNode = rightTermNodeQuery(statementNode), leftTermVerified = (0, _term.default)(leftTermNode, types, context), rightTermVerified = (0, _term.default)(rightTermNode, types, context);
+            if (leftTermVerified && rightTermVerified) {
+                var firstType = (0, _array.first)(types), secondType = (0, _array.second)(types), leftType = firstType, rightType = secondType, leftTermString = (0, _string.nodeAsString)(leftTermNode), rightTermString = (0, _string.nodeAsString)(rightTermNode);
+                if (leftType === null && rightType === null) {
+                    proofContext.error("The types of the '".concat(leftTermString, "' and '").concat(rightTermString, "' terms are both undefined and therefore the terms cannot be equated."));
+                } else if (rightType === null) {
+                    var type = leftType, termNode = rightTermNode, variable = addVariable(type, termNode, proofContext);
+                    if (variable !== null) {
+                        var leftTypeName = leftType.getName();
+                        proofContext.info("The '".concat(rightTermString, "' variable has been given the '").concat(leftTypeName, "' type."));
+                        statementVerifiedAsEquality = true;
+                    }
+                } else if (leftType === null) {
+                    var type1 = rightType, termNode1 = leftType, variable1 = addVariable(type1, termNode1, proofContext);
+                    if (variable1 !== null) {
+                        var rightTypeName = rightType.getName();
+                        proofContext.info("The '".concat(rightTermString, "' variable has been given the '").concat(rightTypeName, "' type."));
+                        statementVerifiedAsEquality = true;
+                    }
+                } else {
+                    var leftTypeMatchesRightType = leftType.match(rightType);
+                    if (!leftTypeMatchesRightType) {
+                        proofContext.error("The types of the '".concat(leftTermString, "' and '").concat(rightTermString, "' terms do not match and therefore the terms cannot be equated."));
+                    } else {
+                        var derived = proofContext.isDerived();
+                        if (!derived) {
+                            statementVerifiedAsEquality = true;
+                        } else {
+                            var equality = _equality.default.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode), proofSteps = proofContext.getProofSteps(), equalities = equalitiesFromProofSteps(proofSteps), equalityEquates = equality.equate(equalities, proofContext);
+                            statementVerifiedAsEquality = equalityEquates; ///
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (statementVerifiedAsEquality) {
+        proofContext.info("Verified the '".concat(statementString, "' equality."));
+    }
+    statementVerifiedAsEquality ? proofContext.complete(statementNode) : proofContext.halt(statementNode);
+    return statementVerifiedAsEquality;
+}
+function equalitiesFromProofSteps(proofSteps) {
+    var start = -_constants.MAXIMUM_INDEXES_LENGTH; ///
+    proofSteps = proofSteps.slice(start); ///
+    var equalities = proofSteps.reduce(function(equalities, proofStep, index) {
+        var equality = _equality.default.fromProofStep(proofStep);
+        if (equality !== null) {
+            equalities.push(equality);
+        }
+        return equalities;
+    }, []);
+    return equalities;
+}
+function addVariable(type, termNode, proofContext) {
+    var variable = null;
+    var variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, proofContext);
+    if (termVerifiedAsVariable) {
+        var firstVariable = (0, _array.first)(variables);
+        variable = firstVariable; ///
+        var name = variable.getName();
+        variable = _variable.default.fromTypeAndName(type, name); ///
+        proofContext.addVariable(variable);
+    }
+    return variable;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/statementAsEquality.js"],"sourcesContent":["\"use strict\";\n\nimport Equality from \"../equality\";\nimport Variable from \"../variable\";\nimport verifyTerm from \"../verify/term\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { first, second } from \"../utilities/array\";\nimport { verifyTermAsVariable } from \"../verify/term\";\nimport { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from \"../constants\";\n\nconst specialNodeQuery = nodeQuery(\"/statement/@special!\"),\n      leftTermNodeQuery = nodeQuery(\"/statement/term[0]\"),\n      rightTermNodeQuery = nodeQuery(\"/statement/term[1]\");\n\nexport default function verifyStatementAsEquality(statementNode, proofContext) {\n  let statementVerifiedAsEquality = false;\n\n  proofContext.begin(statementNode);\n\n  const statementString = nodeAsString(statementNode);\n\n  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);\n\n  const specialNode = specialNodeQuery(statementNode);\n\n  if (specialNode !== null) {\n    const terminalNode = specialNode, ///\n          terminalNodeContent = terminalNode.getContent();\n\n    if (terminalNodeContent === EQUALS_CHARACTER) {\n      const types = [],\n            context = proofContext,  ///\n            leftTermNode = leftTermNodeQuery(statementNode),\n            rightTermNode = rightTermNodeQuery(statementNode),\n            leftTermVerified = verifyTerm(leftTermNode, types, context),\n            rightTermVerified = verifyTerm(rightTermNode, types, context);\n\n      if (leftTermVerified && rightTermVerified) {\n        const firstType = first(types),\n              secondType = second(types),\n              leftType = firstType, ///\n              rightType = secondType, ///\n              leftTermString = nodeAsString(leftTermNode),\n              rightTermString = nodeAsString(rightTermNode);\n\n        if ((leftType === null) && (rightType === null)) {\n          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);\n        } else if (rightType === null) {\n          const type = leftType,  ///\n                termNode = rightTermNode, ///\n                variable = addVariable(type, termNode, proofContext);\n\n          if (variable !== null) {\n            const leftTypeName = leftType.getName();\n\n            proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);\n\n            statementVerifiedAsEquality = true;\n          }\n        } else if (leftType === null) {\n          const type = rightType,  ///\n                termNode = leftType, ///\n                variable = addVariable(type, termNode, proofContext);\n\n          if (variable !== null) {\n            const rightTypeName = rightType.getName();\n\n            proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);\n\n            statementVerifiedAsEquality = true;\n          }\n        } else {\n          const leftTypeMatchesRightType = leftType.match(rightType);\n\n          if (!leftTypeMatchesRightType) {\n            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);\n          } else {\n            const derived = proofContext.isDerived();\n\n            if (!derived) {\n              statementVerifiedAsEquality = true;\n            } else {\n              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),\n                    proofSteps = proofContext.getProofSteps(),\n                    equalities = equalitiesFromProofSteps(proofSteps),\n                    equalityEquates = equality.equate(equalities, proofContext);\n\n              statementVerifiedAsEquality = equalityEquates;  ///\n            }\n          }\n        }\n      }\n    }\n  }\n\n  if (statementVerifiedAsEquality) {\n    proofContext.info(`Verified the '${statementString}' equality.`);\n  }\n\n  statementVerifiedAsEquality ?\n    proofContext.complete(statementNode) :\n      proofContext.halt(statementNode);\n\n  return statementVerifiedAsEquality;\n}\n\nfunction equalitiesFromProofSteps(proofSteps) {\n  const start = -MAXIMUM_INDEXES_LENGTH;  ///\n\n  proofSteps = proofSteps.slice(start); ///\n\n  const equalities = proofSteps.reduce((equalities, proofStep, index) => {\n    const equality = Equality.fromProofStep(proofStep);\n\n    if (equality !== null) {\n      equalities.push(equality);\n    }\n\n    return equalities;\n  }, []);\n\n  return equalities;\n}\n\nfunction addVariable(type, termNode, proofContext) {\n  let variable = null;\n\n  const variables = [],\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);\n\n  if (termVerifiedAsVariable) {\n    const firstVariable = first(variables);\n\n    variable = firstVariable;  ///\n\n    const name = variable.getName();\n\n    variable = Variable.fromTypeAndName(type, name);  ///\n\n    proofContext.addVariable(variable);\n  }\n\n  return variable;\n}\n"],"names":["verifyStatementAsEquality","specialNodeQuery","nodeQuery","leftTermNodeQuery","rightTermNodeQuery","statementNode","proofContext","statementVerifiedAsEquality","begin","statementString","nodeAsString","debug","specialNode","terminalNode","terminalNodeContent","getContent","EQUALS_CHARACTER","types","context","leftTermNode","rightTermNode","leftTermVerified","verifyTerm","rightTermVerified","firstType","first","secondType","second","leftType","rightType","leftTermString","rightTermString","error","type","termNode","variable","addVariable","leftTypeName","getName","info","rightTypeName","leftTypeMatchesRightType","match","derived","isDerived","equality","Equality","fromLeftTermNodeAndRightTermNode","proofSteps","getProofSteps","equalities","equalitiesFromProofSteps","equalityEquates","equate","complete","halt","start","MAXIMUM_INDEXES_LENGTH","slice","reduce","proofStep","index","fromProofStep","push","variables","termVerifiedAsVariable","verifyTermAsVariable","firstVariable","name","Variable","fromTypeAndName"],"mappings":"AAAA;;;;+BAgBA;;;eAAwBA;;;6DAdH;6DACA;0DACE;qBAEG;sBACG;qBACC;yBAE2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzD,IAAMC,mBAAmBC,IAAAA,gBAAS,EAAC,yBAC7BC,oBAAoBD,IAAAA,gBAAS,EAAC,uBAC9BE,qBAAqBF,IAAAA,gBAAS,EAAC;AAEtB,SAASF,0BAA0BK,aAAa,EAAEC,YAAY,EAAE;IAC7E,IAAIC,8BAA8B,KAAK;IAEvCD,aAAaE,KAAK,CAACH;IAEnB,IAAMI,kBAAkBC,IAAAA,oBAAY,EAACL;IAErCC,aAAaK,KAAK,CAAC,AAAC,kBAAiC,OAAhBF,iBAAgB;IAErD,IAAMG,cAAcX,iBAAiBI;IAErC,IAAIO,gBAAgB,IAAI,EAAE;QACxB,IAAMC,eAAeD,aACfE,sBAAsBD,aAAaE,UAAU;QAEnD,IAAID,wBAAwBE,2BAAgB,EAAE;YAC5C,IAAMC,QAAQ,EAAE,EACVC,UAAUZ,cACVa,eAAehB,kBAAkBE,gBACjCe,gBAAgBhB,mBAAmBC,gBACnCgB,mBAAmBC,IAAAA,aAAU,EAACH,cAAcF,OAAOC,UACnDK,oBAAoBD,IAAAA,aAAU,EAACF,eAAeH,OAAOC;YAE3D,IAAIG,oBAAoBE,mBAAmB;gBACzC,IAAMC,YAAYC,IAAAA,YAAK,EAACR,QAClBS,aAAaC,IAAAA,aAAM,EAACV,QACpBW,WAAWJ,WACXK,YAAYH,YACZI,iBAAiBpB,IAAAA,oBAAY,EAACS,eAC9BY,kBAAkBrB,IAAAA,oBAAY,EAACU;gBAErC,IAAI,AAACQ,aAAa,IAAI,IAAMC,cAAc,IAAI,EAAG;oBAC/CvB,aAAa0B,KAAK,CAAC,AAAC,qBAA4CD,OAAxBD,gBAAe,WAAyB,OAAhBC,iBAAgB;gBAClF,OAAO,IAAIF,cAAc,IAAI,EAAE;oBAC7B,IAAMI,OAAOL,UACPM,WAAWd,eACXe,WAAWC,YAAYH,MAAMC,UAAU5B;oBAE7C,IAAI6B,aAAa,IAAI,EAAE;wBACrB,IAAME,eAAeT,SAASU,OAAO;wBAErChC,aAAaiC,IAAI,CAAC,AAAC,QAAwDF,OAAjDN,iBAAgB,mCAA8C,OAAbM,cAAa;wBAExF9B,8BAA8B,IAAI;oBACpC,CAAC;gBACH,OAAO,IAAIqB,aAAa,IAAI,EAAE;oBAC5B,IAAMK,QAAOJ,WACPK,YAAWN,UACXO,YAAWC,YAAYH,OAAMC,WAAU5B;oBAE7C,IAAI6B,cAAa,IAAI,EAAE;wBACrB,IAAMK,gBAAgBX,UAAUS,OAAO;wBAEvChC,aAAaiC,IAAI,CAAC,AAAC,QAAwDC,OAAjDT,iBAAgB,mCAA+C,OAAdS,eAAc;wBAEzFjC,8BAA8B,IAAI;oBACpC,CAAC;gBACH,OAAO;oBACL,IAAMkC,2BAA2Bb,SAASc,KAAK,CAACb;oBAEhD,IAAI,CAACY,0BAA0B;wBAC7BnC,aAAa0B,KAAK,CAAC,AAAC,qBAA4CD,OAAxBD,gBAAe,WAAyB,OAAhBC,iBAAgB;oBAClF,OAAO;wBACL,IAAMY,UAAUrC,aAAasC,SAAS;wBAEtC,IAAI,CAACD,SAAS;4BACZpC,8BAA8B,IAAI;wBACpC,OAAO;4BACL,IAAMsC,WAAWC,iBAAQ,CAACC,gCAAgC,CAAC5B,cAAcC,gBACnE4B,aAAa1C,aAAa2C,aAAa,IACvCC,aAAaC,yBAAyBH,aACtCI,kBAAkBP,SAASQ,MAAM,CAACH,YAAY5C;4BAEpDC,8BAA8B6C,iBAAkB,GAAG;wBACrD,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI7C,6BAA6B;QAC/BD,aAAaiC,IAAI,CAAC,AAAC,iBAAgC,OAAhB9B,iBAAgB;IACrD,CAAC;IAEDF,8BACED,aAAagD,QAAQ,CAACjD,iBACpBC,aAAaiD,IAAI,CAAClD,cAAc;IAEpC,OAAOE;AACT;AAEA,SAAS4C,yBAAyBH,UAAU,EAAE;IAC5C,IAAMQ,QAAQ,CAACC,iCAAsB,EAAG,GAAG;IAE3CT,aAAaA,WAAWU,KAAK,CAACF,QAAQ,GAAG;IAEzC,IAAMN,aAAaF,WAAWW,MAAM,CAAC,SAACT,YAAYU,WAAWC,OAAU;QACrE,IAAMhB,WAAWC,iBAAQ,CAACgB,aAAa,CAACF;QAExC,IAAIf,aAAa,IAAI,EAAE;YACrBK,WAAWa,IAAI,CAAClB;QAClB,CAAC;QAED,OAAOK;IACT,GAAG,EAAE;IAEL,OAAOA;AACT;AAEA,SAASd,YAAYH,IAAI,EAAEC,QAAQ,EAAE5B,YAAY,EAAE;IACjD,IAAI6B,WAAW,IAAI;IAEnB,IAAM6B,YAAY,EAAE,EACdC,yBAAyBC,IAAAA,0BAAoB,EAAChC,UAAU8B,WAAW1D;IAEzE,IAAI2D,wBAAwB;QAC1B,IAAME,gBAAgB1C,IAAAA,YAAK,EAACuC;QAE5B7B,WAAWgC,eAAgB,GAAG;QAE9B,IAAMC,OAAOjC,SAASG,OAAO;QAE7BH,WAAWkC,iBAAQ,CAACC,eAAe,CAACrC,MAAMmC,OAAQ,GAAG;QAErD9D,aAAa8B,WAAW,CAACD;IAC3B,CAAC;IAED,OAAOA;AACT"}

package/lib/verify/statementTypeAssertion.js

@@ -0,0 +1,82 @@
+"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, proofContext) {
+    var typeAssertionVerified = 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 {
+            var context = proofContext, termNode = termNodeQuery(typeAssertionNode), variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
+            if (termVerifiedAsVariable) {
+                var variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+                typeAssertionVerified = variableTypeAssertionVerified; ///
+            } else {
+                var termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+                typeAssertionVerified = termTypeAssertionVerified; ///
+            }
+        }
+    }
+    if (typeAssertionVerified) {
+        proofContext.info("Verified the '".concat(statementString, "' statement type assertion."));
+    }
+    typeAssertionVerified ? proofContext.complete(statementNode) : proofContext.halt(statementNode);
+    return typeAssertionVerified;
+}
+function verifyTermTypeAssertion(typeAssertionNode, 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, assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+        if (!assertedTypeEqualToOrSubTypeOfTermType) {
+            var termString = (0, _string.nodeAsString)(termNode);
+            proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(termString, "' term type."));
+        } else {
+            termTypeAssertionVerified = true;
+        }
+    }
+    return termTypeAssertionVerified;
+}
+function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
+    var variableTypeAssertionVerified = false;
+    var context = proofContext, variables = [], termNode = termNodeQuery(typeAssertionNode);
+    (0, _term.verifyTermAsVariable)(termNode, variables, context);
+    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 {
+        var derived = proofContext.isDerived();
+        if (!derived) {
+            var type = assertedType, name = variableName, variable1 = _variable.default.fromTypeAndName(type, name);
+            proofContext.addVariable(variable1);
+        }
+        variableTypeAssertionVerified = true;
+    }
+    return variableTypeAssertionVerified;
+}
+
+//# 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, proofContext) {\n  let typeAssertionVerified = 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      const context = proofContext, ///\n            termNode = termNodeQuery(typeAssertionNode),\n            variables = [],\n            termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n      if (termVerifiedAsVariable) {\n        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);\n\n        typeAssertionVerified = variableTypeAssertionVerified;  ///\n      } else {\n        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);\n\n        typeAssertionVerified = termTypeAssertionVerified;  ///\n      }\n    }\n  }\n\n  if (typeAssertionVerified) {\n    proofContext.info(`Verified the '${statementString}' statement type assertion.`);\n  }\n\n  typeAssertionVerified ?\n    proofContext.complete(statementNode) :\n      proofContext.halt(statementNode);\n\n  return typeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, 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          assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n    if (!assertedTypeEqualToOrSubTypeOfTermType) {\n      const termString = nodeAsString(termNode);\n\n      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);\n    } else {\n      termTypeAssertionVerified = true;\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\nfunction verifyVariableTypeAssertion(typeAssertionNode, proofContext) {\n  let variableTypeAssertionVerified = false;\n\n  const context = proofContext, ///\n        variables = [],\n        termNode = termNodeQuery(typeAssertionNode);\n\n  verifyTermAsVariable(termNode, variables, context);\n\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    const derived = proofContext.isDerived();\n\n    if (!derived) {\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  return variableTypeAssertionVerified;\n}\n"],"names":["verifyStatementTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNodeQuery","statementNode","proofContext","typeAssertionVerified","begin","statementString","nodeAsString","debug","typeAssertionNode","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","error","context","termNode","variables","termVerifiedAsVariable","verifyTermAsVariable","variableTypeAssertionVerified","verifyVariableTypeAssertion","termTypeAssertionVerified","verifyTermTypeAssertion","info","complete","halt","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","assertedTypeName","assertedType","findTypeByTypeName","firstType","first","termType","assertedTypeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf","termString","firstVariable","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSubTypeOfVariableType","derived","isDerived","type","name","Variable","fromTypeAndName","addVariable"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.478",
+  "version": "0.0.480",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,9 +12,9 @@
   "dependencies": {
     "argumentative": "^2.0.21",
     "necessary": "^11.2.1",
-    "occam-custom-grammars": "^5.0.375",
+    "occam-custom-grammars": "^5.0.376",
     "occam-dom": "^3.1.1",
-    "occam-file-system": "^5.0.134",
+    "occam-file-system": "^5.0.135",
     "occam-grammar-utilities": "^7.0.66"
   },
   "devDependencies": {

package/src/conclusion.js

@@ -4,7 +4,7 @@ import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { metavariableNameFromMetavariableNode } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "./ruleNames";
 
 export default class Conclusion {
   constructor(metastatementNode) {
@@ -15,10 +15,19 @@ export default class Conclusion {
     return this.metastatementNode;
   }
 
+  matchStatementNode(statementNode, substitutions) {
+    const nonTerminalNode = statementNode,  ///
+          conclusionNonTerminalNode = this.metastatementNode,  ///
+          conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = conclusionNonTerminalNodeMatches; ///
+
+    return statementNodeMatches;
+  }
+
   matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           conclusionNonTerminalNode = this.metastatementNode,  ///
-          conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          conclusionNonTerminalNodeMatches = metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
           metastatementNodeMatches = conclusionNonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
@@ -50,7 +59,7 @@ export default class Conclusion {
   }
 }
 
-function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
+function matchConclusionNode(conclusionNode, node, substitutions) {
   let conclusionNodeMatches = false;
 
   const nodeTerminalNode = node.isTerminalNode(),
@@ -60,13 +69,13 @@ function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
     if (nodeTerminalNode) {
       const terminalNode = node,  ///
             conclusionTerminalNode = conclusionNode,  ///
-            conclusionTerminalNodeMatches = matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions);
+            conclusionTerminalNodeMatches = matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, substitutions);
 
       conclusionNodeMatches = conclusionTerminalNodeMatches;  ///
     } else {
       const nonTerminalNode = node, ///
             conclusionNonTerminalNode = conclusionNode,  ///
-            conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+            conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions);
 
       conclusionNodeMatches = conclusionNonTerminalNodeMatches; ///
     }
@@ -76,13 +85,13 @@ function matchConclusionNode(conclusionNode, node, metaSubstitutions) {
 }
 
 function matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
-  let conclusionNodesMatches = false;
+  let conclusionNodesMatch = false;
 
   const nodesLength = nodes.length,
         conclusionNodesLength = conclusionNodes.length;
 
   if (nodesLength === conclusionNodesLength) {
-    conclusionNodesMatches = nodes.every((node, index) => {
+    conclusionNodesMatch = nodes.every((node, index) => {
       const conclusionNode = conclusionNodes[index],
             conclusionNodeMatches = matchConclusionNode(conclusionNode, node, metaSubstitutions);
 
@@ -92,51 +101,165 @@ function matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
     });
   }
 
-  return conclusionNodesMatches;
+  return conclusionNodesMatch;
+}
+
+function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, substitutions) {
+  const matches = conclusionTerminalNode.match(terminalNode),
+        conclusionTerminalNodeMatches = matches;  ///
+
+  return conclusionTerminalNodeMatches;
+}
+
+function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions) {
+  let conclusionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        childNodes = nonTerminalNode.getChildNodes(),
+        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
+        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        nodes = childNodes, ///
+        conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
+        ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
+        conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+  if (ruleNameStatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
+    const statementNode = nonTerminalNode,  ///
+          conclusionMetastatementNode = conclusionNonTerminalNode,  ///
+          conclusionMetastatementNodeMatches = matchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, substitutions);
+
+    if (conclusionMetastatementNodeMatches) {
+      conclusionNonTerminalNodeMatches = true; ///
+    } else {
+      const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
+
+      conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
+    }
+  } else if (ruleName === conclusionNonTerminalNodeRuleName) {
+    const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
+
+    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
+  }
+
+  return conclusionNonTerminalNodeMatches;
 }
 
-function matchConclusionMetavariable(conclusionMetavariableNode, nodes, metaSubstitutions) {
-  let conclusionMetavariableMatches = true;
+function matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions) {
+  let conclusionMetavariableNodeMatches = true;
 
   const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
+        substitution = substitutions.find((substitution) => {
+          const metavariableName = substitution.getMetavariableName();
 
           if (metavariableName === conclusionMetavariableName) {
             return true;
           }
         }) || null;
 
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+  if (substitution !== null) {
+    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+    conclusionMetavariableNodeMatches = substitutionNodesMatch;  ///
+  }
+
+  return conclusionMetavariableNodeMatches;
+}
+
+function matchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, substitutions) {
+  let conclusionMetastatementNodeMatches = false;
+
+  const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
+        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
+
+  if (conclusionNonTerminalNodeChildNodesLength === 1) {
+    const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
+          conclusionChildNode = firstConclusionChildNode,  ///
+          conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
+
+    if (conclusionChildNodeNonTerminalNode) {
+      const conclusionNonTerminalChildNode = conclusionChildNode,  ///
+            conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
+            conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+      if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
+        const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
+              conclusionMetavariableNodeMatches = matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions);
+
+        conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
+      }
+    }
+  }
+
+  return conclusionMetastatementNodeMatches;
+}
+
+function metaMatchConclusionNode(conclusionNode, node, metaSubstitutions) {
+  let conclusionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = conclusionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            conclusionTerminalNode = conclusionNode,  ///
+            conclusionTerminalNodeMatches = metaMatchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions);
+
+      conclusionNodeMatches = conclusionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            conclusionNonTerminalNode = conclusionNode,  ///
+            conclusionNonTerminalNodeMatches = metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      conclusionNodeMatches = conclusionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return conclusionNodeMatches;
+}
 
-    conclusionMetavariableMatches = metaSubstitutionNodesMatch;  ///
+function metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
+  let conclusionNodesMatch = false;
+
+  const nodesLength = nodes.length,
+        conclusionNodesLength = conclusionNodes.length;
+
+  if (nodesLength === conclusionNodesLength) {
+    conclusionNodesMatch = nodes.every((node, index) => {
+      const conclusionNode = conclusionNodes[index],
+            conclusionNodeMatches = metaMatchConclusionNode(conclusionNode, node, metaSubstitutions);
+
+      if (conclusionNodeMatches) {
+        return true;
+      }
+    });
   }
 
-  return conclusionMetavariableMatches;
+  return conclusionNodesMatch;
 }
 
-function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions) {
+function metaMatchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions) {
   const matches = conclusionTerminalNode.match(terminalNode),
         conclusionTerminalNodeMatches = matches;  ///
 
   return conclusionTerminalNodeMatches;
 }
 
-function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+function metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
   let conclusionNonTerminalNodeMatches = false;
 
   const ruleName = nonTerminalNode.getRuleName(),
-        conclusionRuleName = conclusionNonTerminalNode.getRuleName(); ///
+        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName();
 
-  if (ruleName === conclusionRuleName) {
+  if (ruleName === conclusionNonTerminalNodeRuleName) {
     const childNodes = nonTerminalNode.getChildNodes(),
-          conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
+          conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
           nodes = childNodes, ///
-          conclusionNodes = conclusionChildNodes, ///
-          conclusionChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
+          conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
+          conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
 
-    conclusionNonTerminalNodeMatches = conclusionChildNodesMatches; ///
+    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
 
     if (!conclusionNonTerminalNodeMatches) {
       const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
@@ -144,7 +267,7 @@ function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNo
       if (ruleNameMetastatementRuleName) {
         const metastatementNode = nonTerminalNode,  ///
               conclusionMetastatementNode = conclusionNonTerminalNode,  ///
-              conclusionMetastatementNodeMatches = matchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions);
+              conclusionMetastatementNodeMatches = metaMatchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions);
 
         conclusionNonTerminalNodeMatches = conclusionMetastatementNodeMatches; ///
       }
@@ -154,15 +277,36 @@ function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNo
   return conclusionNonTerminalNodeMatches;
 }
 
-function matchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions) {
+function metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions) {
+  let conclusionMetavariableNodeMatches = true;
+
+  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+      const metavariableName = metaSubstitution.getMetavariableName();
+
+      if (metavariableName === conclusionMetavariableName) {
+        return true;
+      }
+    }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
+
+    conclusionMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
+  }
+
+  return conclusionMetavariableNodeMatches;
+}
+
+function metaMatchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions) {
   let conclusionMetastatementNodeMatches = false;
 
   const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
-        conclusionChildNodes = conclusionNonTerminalNode.getChildNodes(),
-        conclusionChildNodesLength = conclusionChildNodes.length;
+        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
 
-  if (conclusionChildNodesLength === 1) {
-    const firstConclusionChildNode = first(conclusionChildNodes),
+  if (conclusionNonTerminalNodeChildNodesLength === 1) {
+    const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
           conclusionChildNode = firstConclusionChildNode,  ///
           conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
 
@@ -173,12 +317,9 @@ function matchConclusionMetastatementNode(conclusionMetastatementNode, metastate
 
       if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
-              nonTerminalNode = metastatementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              conclusionMetaVariableMatches = matchConclusionMetavariable(conclusionMetavariableNode, nodes, metaSubstitutions);
+              conclusionMetavariableNodeMatches = metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions);
 
-        conclusionMetastatementNodeMatches = conclusionMetaVariableMatches; ///
+        conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
       }
     }
   }

package/src/constants.js

@@ -7,6 +7,7 @@ export const BOOLEAN = "boolean";
 export const EMPTY_STRING = "";
 export const LEFT_BRACKET = "(";
 export const RIGHT_BRACKET = ")";
+export const EQUALS_CHARACTER = "=";
 export const MAXIMUM_INDEXES_LENGTH = 10;
 export const MAXIMUM_PERMUTATION_LENGTH = 5;
 export const BRACKETED_CHILD_NODES_LENGTH = 3;