occam-verify-cli 0.0.518 → 0.0.519

package/src/verify/assertion/type.js

@@ -70,12 +70,13 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
             variable = firstVariable, ///
             variableName = variable.getName(),
             variableType = variable.getType(),
-            assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
-                                                            true : ///
-                                                              assertedType.isEqualToOrSubTypeOf(variableType);
+            assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
       if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-        proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);
+        const assertedTypeName = assertedType.getName(),
+              variableTypeName = variableType.getName();
+
+        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`);
       } else {
         const type = assertedType,  ///
               typeAssertion = TypeAssertion.fromTypeAndVariableName(type, variableName),
@@ -115,7 +116,10 @@ function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
                                                assertedType.isEqualTo(termType);
 
       if (!assertedTypeEqualToTermType) {
-        proofContext.error(`The asserted type is not equal to the '${termString}' term type.`);
+        const termTypeName = termType.getName(),
+              assertedTypeName = assertedType.getName();
+
+        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`);
       } else {
         const type = assertedType,  ///
               typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),

package/src/verify/statement.js

@@ -1,14 +1,18 @@
 "use strict";
 
 import verifyTerm from "../verify/term";
+import EqualityAssertion from "../assertion/equality";
+import equalityCombinator from "../ocmbinator/equality";
+import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
+import { objectType } from "../type";
 import { nodeAsString } from "../utilities/string";
+import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
-import bracketedCombinator from "../ocmbinator/bracketed";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
@@ -21,15 +25,20 @@ export default function verifyStatement(statementNode, assertions, proofContext)
 
   proofContext.begin(statementNode);
 
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  if (!statementVerified) {
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, assertions, proofContext);
 
-  if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, proofContext);
+    statementVerified = statementVerifiedAsEquality;  //
+  }
 
-    statementVerified = typeAssertionVerified; ///
-  } else {
-    const context = proofContext, ///
-          statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
+  if (!statementVerified) {
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, proofContext);
+
+    statementVerified = statementVerifiedAsTypeAssertion; ///
+  }
+
+  if (!statementVerified) {
+    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, proofContext);
 
     statementVerified = statementVerifiedAgainstCombinators;  ///
   }
@@ -41,17 +50,50 @@ export default function verifyStatement(statementNode, assertions, proofContext)
   return statementVerified;
 }
 
-function verifyStatementAgainstCombinators(statementNode, context) {
-  let statementVerifiedAgainstCombinators = false;
+function verifyStatementAsEquality(statementNode, assertions, proofContext) {
+  let statementVerifiedAsEquality = false;
+
+  const combinator = equalityCombinator,  ///
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, proofContext);
+
+  if (statementVerifiedAgainstCombinator) {
+    const equalityAssertion = EqualityAssertion.fromStatementNode(statementNode),
+          assertion = equalityAssertion;  ///
+
+    assertions.push(assertion);
+
+    statementVerifiedAsEquality = true;
+  }
+
+  return statementVerifiedAsEquality;
+}
+
+function verifyStatementAsTypeAssertion(statementNode, assertions, proofContext) {
+  let statementVerifiedAsTypeAssertion = false;
 
-  context.begin(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-  const combinators = context.getCombinators();
+  if (typeAssertionNode !== null) {
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, proofContext);
 
-  combinators.unshift(bracketedCombinator);
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+  }
+
+  return statementVerifiedAsTypeAssertion;
+}
+
+function verifyStatementAgainstCombinators(statementNode, proofContext) {
+  let statementVerifiedAgainstCombinators = false;
+
+  let combinators = proofContext.getCombinators();
+
+  combinators = [ ///
+    bracketedCombinator,
+    ...combinators
+  ];
 
   const combinator = combinators.find((combinator) => {
-          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, proofContext);
 
           if (statementVerifiedAgainstCombinator) {
             return true;
@@ -62,24 +104,20 @@ function verifyStatementAgainstCombinators(statementNode, context) {
     statementVerifiedAgainstCombinators = true;
   }
 
-  statementVerifiedAgainstCombinators ?
-    context.complete(statementNode) :
-      context.halt(statementNode);
-
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+function verifyStatementAgainstCombinator(statementNode, combinator, proofContext) {
   const combinatorStatementNode = combinator.getStatementNode(),
         node = statementNode,  ///
         combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, context),
+        nodeVerified = verifyNode(node, combinatorNode, proofContext),
         statementVerifiedAgainstCombinator = nodeVerified;  ///
 
   return statementVerifiedAgainstCombinator;
 }
 
-function verifyNode(node, combinatorNode, context) {
+function verifyNode(node, combinatorNode, proofContext) {
   let nodeVerified;
 
   const nodeTerminalNode = node.isTerminalNode(),
@@ -89,13 +127,13 @@ function verifyNode(node, combinatorNode, context) {
     if (nodeTerminalNode) {
       const terminalNode = node,  ///
             combinatorTerminalNode = combinatorNode,  ///
-            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, context);
+            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, proofContext);
 
       nodeVerified = terminalNodeVerified;  ///
     } else {
       const nonTerminalNode = node, ///
             combinatorNonTerminalNode = combinatorNode,  ///
-            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context);
+            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proofContext);
 
       nodeVerified = nonTerminalNodeVerified; ///
     }
@@ -104,7 +142,7 @@ function verifyNode(node, combinatorNode, context) {
   return nodeVerified;
 }
 
-function verifyNodes(nodes, combinatorNodes, context) {
+function verifyNodes(nodes, combinatorNodes, proofContext) {
   let nodesVerified = false;
 
   const nodesLength = nodes.length,
@@ -113,7 +151,7 @@ function verifyNodes(nodes, combinatorNodes, context) {
   if (nodesLength === combinatorNodesLength) {
     nodesVerified = nodes.every((node, index) => {
       const combinatorNode = combinatorNodes[index],
-            nodeVerified = verifyNode(node, combinatorNode, context);
+            nodeVerified = verifyNode(node, combinatorNode, proofContext);
 
       if (nodeVerified) {
         return true;
@@ -124,7 +162,7 @@ function verifyNodes(nodes, combinatorNodes, context) {
   return nodesVerified;
 }
 
-function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
+function verifyTerminalNode(terminalNode, combinatorTerminalNode, proofContext) {
   let terminalNodeVerified = false;
 
   const matches = terminalNode.match(combinatorTerminalNode);
@@ -136,7 +174,7 @@ function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
   return terminalNodeVerified;
 }
 
-function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context) {
+function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proofContext) {
   let nonTerminalNodeVerified = false;
 
   const ruleName = nonTerminalNode.getRuleName(), ///
@@ -147,7 +185,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, conte
       case ARGUMENT_RULE_NAME: {
         const argumentNode = nonTerminalNode, ///
               combinatorArgumentNode = combinatorNonTerminalNode, ///
-              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
+              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext);
 
         nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -157,7 +195,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, conte
       case META_ARGUMENT_RULE_NAME: {
         const metaArgumentNode = nonTerminalNode, ///
               combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
+              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, proofContext);
 
         nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -169,7 +207,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, conte
               combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
               nodes = childNodes, ///
               combinatorNodes = combinatorChildNodes, ///
-              nodesVerified = verifyNodes(nodes, combinatorNodes, context);
+              nodesVerified = verifyNodes(nodes, combinatorNodes, proofContext);
 
         nonTerminalNodeVerified = nodesVerified; ///
 
@@ -181,7 +219,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, conte
   return nonTerminalNodeVerified;
 }
 
-function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
+function verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext) {
   let argumentNodeVerified = false;
 
   const termNode = termNodeQuery(argumentNode);
@@ -189,9 +227,10 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`);
+    proofContext.error(`The ${argumentString} argument should be a term, not a type`);
   } else {
     const types = [],
+          context = proofContext, ///
           termVerified = verifyTerm(termNode, types, context);
 
     if (termVerified) {
@@ -199,7 +238,9 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
             termType = firstType, ///
             typeNode = typeNodeQuery(combinatorArgumentNode),
             typeName = typeNameFromTypeNode(typeNode),
-            type = context.findTypeByTypeName(typeName),
+            type = (typeName === OBJECT_TYPE_NAME) ?
+                     objectType :  ///
+                       proofContext.findTypeByTypeName(typeName),
             statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
       if (statementTypeEqualToOrSubTypeOfType) {
@@ -211,7 +252,7 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   return argumentNodeVerified;
 }
 
-function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
+function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, proofContext) {
   let metaArgumentNodeVerified = false;
 
   const statementNode = statementNodeQuery(metaArgumentNode);
@@ -219,10 +260,10 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
   if (statementNode === null) {
     const metaArgumentString = nodeAsString(metaArgumentNode);
 
-    context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
+    proofContext.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
   } else {
     const assertions = null,
-          statementVerified = verifyStatement(statementNode, assertions, context);
+          statementVerified = verifyStatement(statementNode, assertions, proofContext);
 
     if (statementVerified) {
       const combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
@@ -238,7 +279,7 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
       if (!metaArgumentNodeVerified) {
         const combinatorMetaargumentString = nodeAsString(combinatorMetaargumentNode);
 
-        context.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
+        proofContext.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
       }
     }
   }

package/src/verify/term.js

@@ -1,7 +1,9 @@
 "use strict";
 
 import { first } from "../utilities/array";
+import { objectType } from "../type";
 import { nodeAsString } from "../utilities/string";
+import { OBJECT_TYPE_NAME } from "../typeNames";
 import { ARGUMENT_RULE_NAME } from "../ruleNames";
 import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
 
@@ -224,7 +226,9 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
             termType = firstType, ///
             typeNode = typeNodeQuery(constructorArgumentNode),
             typeName = typeNameFromTypeNode(typeNode),
-            type = context.findTypeByTypeName(typeName),
+            type = (typeName === OBJECT_TYPE_NAME) ?
+                     objectType :  ///
+                       context.findTypeByTypeName(typeName),
             termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
       if (termTypeEqualToOrSubTypeOfType) {

package/src/verify/variable.js

@@ -2,6 +2,7 @@
 
 import Variable from "../variable";
 
+import { objectType } from "../type";
 import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
 
@@ -25,7 +26,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
     const typeName = typeNameFromTypeNode(typeNode);
     
     if (typeName === null) {
-      const type = null,
+      const type = objectType,
             name = variableName;  ///
 
       variable = Variable.fromTypeAndName(type, name);

package/lib/context/release/bracketedCombinator.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _occamGrammarUtilities = require("occam-grammar-utilities");
-var _occamCustomGrammars = require("occam-custom-grammars");
-var _customGrammar = require("../../utilities/customGrammar");
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var florenceLexerFromCombinedCustomGrammar = _occamCustomGrammars.lexersUtilities.florenceLexerFromCombinedCustomGrammar, florenceParserFromCombinedCustomGrammar = _occamCustomGrammars.parsersUtilities.florenceParserFromCombinedCustomGrammar;
-var combinedCustomGrammar = (0, _customGrammar.combinedCustomGrammarFromNothing)(), florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar), florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
-var BracketedCombinatorReleaseContext = /*#__PURE__*/ function() {
-    function BracketedCombinatorReleaseContext() {
-        _classCallCheck(this, BracketedCombinatorReleaseContext);
-    }
-    _createClass(BracketedCombinatorReleaseContext, [
-        {
-            key: "nodeFromContentAndRuleName",
-            value: function nodeFromContentAndRuleName(content, ruleName) {
-                var ruleMap = florenceParser.getRuleMap(), rule = ruleMap[ruleName], tokens = florenceLexer.tokenise(content), node = florenceParser.parse(tokens, rule);
-                if (node !== null) {
-                    (0, _occamGrammarUtilities.rewriteNodes)(node);
-                }
-                return node;
-            }
-        }
-    ], [
-        {
-            key: "fromNothing",
-            value: function fromNothing() {
-                var bracketedCombinatorReleaseContext = new BracketedCombinatorReleaseContext();
-                return bracketedCombinatorReleaseContext;
-            }
-        }
-    ]);
-    return BracketedCombinatorReleaseContext;
-}();
-var bracketedCombinatorReleaseContext = BracketedCombinatorReleaseContext.fromNothing();
-var _default = bracketedCombinatorReleaseContext;
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/type/object.js

@@ -1,9 +0,0 @@
-"use strict";
-
-import Type from "../type";
-
-export default class ObjectType extends Type {
-  static fromNothing() {
-
-  }
-}