occam-verify-cli 1.0.228 → 1.0.233

package/src/dom/type.js

@@ -227,10 +227,10 @@ class Type {
 
   static name = "Type";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name, provisional } = json,
-          properties = propertiesFromJSON(json, fileContext),
-          superTypes = superTypesFromJSON(json, fileContext),
+          properties = propertiesFromJSON(json, context),
+          superTypes = superTypesFromJSON(json, context),
           typeName = name,  ///
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
@@ -238,15 +238,15 @@ class Type {
     return type;
   }
 
-  static fromTypeNode(typeNode, fileContext) {
-    const type = typeFromTypeNode(typeNode, fileContext);
+  static fromTypeNode(typeNode, context) {
+    const type = typeFromTypeNode(typeNode, context);
 
     return type;
   }
 
-  static fromTypeAssertionNode(typeAssertionNode, fileContext) {
+  static fromTypeAssertionNode(typeAssertionNode, context) {
     const typeNode = typeAssertionNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, fileContext);
+          type = typeFromTypeNode(typeNode, context);
 
     return type;
   }
@@ -266,38 +266,38 @@ class Type {
     return type;
   }
 
-  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
     const typeNode = propertyDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, fileContext);
+          type = typeFromTypeNode(typeNode, context);
 
     return type;
   }
 
-  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
+  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
     const properties = [],
           provisional = simpleTypeDeclarationNode.isProvisional(),
           typeName = simpleTypeDeclarationNode.getTypeName(),
           name = typeName,  ///
-          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext),
+          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
   }
 
-  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
     const provisional = complexTypeDeclarationNode.isProvisional(),
           typeName = complexTypeDeclarationNode.getTypeName(),
           name = typeName,
-          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
     let type;
 
     const typeNode = constructorDeclarationNode.getTypeNode();
@@ -307,7 +307,7 @@ class Type {
     } else {
       const provisional = constructorDeclarationNode.isProvisional();
 
-      type = typeFromTypeNode(typeNode, fileContext);
+      type = typeFromTypeNode(typeNode, context);
 
       type.setProvisional(provisional);
     }
@@ -318,10 +318,10 @@ class Type {
 
 export default domAssigned(Type);
 
-function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
+function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, fileContext);
+          const superType = Type.fromTypeNode(superTypeNode, context);
 
           return superType;
         });
@@ -329,10 +329,10 @@ function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, file
   return superTypes;
 }
 
-function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, fileContext);
+          const superType = Type.fromTypeNode(superTypeNode, context);
 
           return superType;
         });
@@ -340,11 +340,11 @@ function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fi
   return superTypes;
 }
 
-function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const { Property } = dom,
         propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
         properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {
-          const property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, fileContext);
+          const property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, context);
 
           return property;
         });

package/src/dom/variable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 
 import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
@@ -88,17 +87,17 @@ export default domAssigned(class Variable {
     return verifies;
   }
 
-  verifyType(fileContext) {
+  verifyType(context) {
     let typeVerifies = false;
 
     const typeString = this.type.getString();
 
-    fileContext.trace(`Verifying the '${typeString}' type...`);
+    context.trace(`Verifying the '${typeString}' type...`);
 
-    const type = fileContext.findTypeByTypeName(typeString);
+    const type = context.findTypeByTypeName(typeString);
 
     if (type === null) {
-      fileContext.debug(`The '${typeString}' type is not present.`);
+      context.debug(`The '${typeString}' type is not present.`);
     } else {
       this.type = type; ///
 
@@ -106,7 +105,7 @@ export default domAssigned(class Variable {
     }
 
     if (typeVerifies) {
-      fileContext.debug(`...verified the '${typeString}' type.`);
+      context.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerifies;
@@ -164,16 +163,14 @@ export default domAssigned(class Variable {
 
   static name = "Variable";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           variableString = string,  ///
           variableNode = variableNodeFromVariableString(variableString, context),
           variableName = variableNode.getVariableName(),
           node = variableNode,
           name = variableName,  ///
-          type = typeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
           propertyRelations = [],
           variable = new Variable(string, node, name, type, propertyRelations);
 
@@ -213,7 +210,7 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
+  static fromVariableDeclarationNode(variableDeclarationNode, context) {
     const { Variable } = dom,
           provisional = variableDeclarationNode.isProvisional(),
           typeNode = variableDeclarationNode.getTypeNode(),

package/src/index.js

@@ -12,6 +12,7 @@ import Proof from "./dom/proof";
 import Error from "./dom/error";
 import Premise from "./dom/premise";
 import Theorem from "./dom/theorem";
+import Section from "./dom/section";
 import Equality from "./dom/equality";
 import MetaType from "./dom/metaType";
 import Subproof from "./dom/subproof";
@@ -28,6 +29,7 @@ import Conjecture from "./dom/conjecture";
 import Conclusion from "./dom/conclusion";
 import Derivation from "./dom/derivation";
 import Combinator from "./dom/combinator";
+import Hypothesis from "./dom/hypothesis";
 import Constructor from "./dom/constructor";
 import Declaration from "./dom/declaration";
 import Supposition from "./dom/supposition";

package/src/node/hypothesis.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class HypothesisNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(HypothesisNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/section.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { HYPOTHESIS_RULE_NAME } from "../ruleNames";
+
+export default class SectionNode extends NonTerminalNode {
+  getHypothesisNodes() {
+    const ruleName = HYPOTHESIS_RULE_NAME,
+          hypothesisNodes = this.getNodesByRuleName(ruleName);
+
+    return hypothesisNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SectionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNodeMap.js

@@ -12,6 +12,7 @@ import LemmaNode from "./node/lemma";
 import ProofNode from "./node/proof";
 import LabelNode from "./node/label";
 import LabelsNode from "./node/labels";
+import SectionNode from "./node/section";
 import PremiseNode from "./node/premise";
 import TheoremNode from "./node/theorem";
 import NonsenseNode from "./node/nonsense";
@@ -32,6 +33,7 @@ import DerivationNode from "./node/derivation";
 import CombinatorNode from "./node/combinator";
 import ConclusionNode from "./node/conclusion";
 import ConjectureNode from "./node/conjecture";
+import HypothesisNode from "./node/hypothesis";
 import SuppositionNode from "./node/supposition";
 import ConstructorNode from "./node/constructor";
 import DeclarationNode from "./node/declaration";
@@ -41,7 +43,6 @@ import MetavariableNode from "./node/metavariable";
 import ProcedureCallNode from "./node/procedureCall";
 import SubDerivationNode from "./node/subDerivation";
 import TypeAssertionNode from "./node/assertion/type";
-import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
 import TermSubstitutionNode from "./node/substitution/term";
@@ -56,6 +57,7 @@ import PropertyDeclarationNode from "./node/declaration/property";
 import variableDeclarationNode from "./node/declaration/variable";
 import StatementSubstitutionNode from "./node/substitution/statement";
 import ReferenceSubstitutionNode from "./node/substitution/reference";
+import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import combinatorDeclarationNode from "./node/declaration/combinator";
 import complexTypeDeclarationNode from "./node/declaration/complexType";
 import constructorDeclarationNode from "./node/declaration/constructor";
@@ -75,6 +77,7 @@ import { RULE_RULE_NAME,
          LABELS_RULE_NAME,
          THEOREM_RULE_NAME,
          PREMISE_RULE_NAME,
+         SECTION_RULE_NAME,
          NONSENSE_RULE_NAME,
          ARGUMENT_RULE_NAME,
          SUBPROOF_RULE_NAME,
@@ -93,6 +96,7 @@ import { RULE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
          CONJECTURE_RULE_NAME,
+         HYPOTHESIS_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          DECLARATION_RULE_NAME,
          SUPPOSITION_RULE_NAME,
@@ -137,6 +141,7 @@ const nonTerminalNodeMap = {
   [LABELS_RULE_NAME]: LabelsNode,
   [THEOREM_RULE_NAME]: TheoremNode,
   [PREMISE_RULE_NAME]: PremiseNode,
+  [SECTION_RULE_NAME]: SectionNode,
   [ARGUMENT_RULE_NAME]: ArgumentNode,
   [PROPERTY_RULE_NAME]: PropertyNode,
   [SUBPROOF_RULE_NAME]: SubproofNode,
@@ -155,6 +160,7 @@ const nonTerminalNodeMap = {
   [CONCLUSION_RULE_NAME]: ConclusionNode,
   [CONJECTURE_RULE_NAME]: ConjectureNode,
   [DERIVATION_RULE_NAME]: DerivationNode,
+  [HYPOTHESIS_RULE_NAME]: HypothesisNode,
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [DECLARATION_RULE_NAME]: DeclarationNode,

package/src/ruleNames.js

@@ -14,6 +14,7 @@ export const LABEL_RULE_NAME = "label";
 export const LABELS_RULE_NAME = "labels";
 export const THEOREM_RULE_NAME = "theorem";
 export const PREMISE_RULE_NAME = "premise";
+export const SECTION_RULE_NAME = "section";
 export const ARGUMENT_RULE_NAME = "argument";
 export const PROPERTY_RULE_NAME = "property";
 export const EQUALITY_RULE_NAME = "equality";
@@ -32,6 +33,7 @@ export const COMBINATOR_RULE_NAME = "combinator";
 export const CONCLUSION_RULE_NAME = "conclusion";
 export const CONJECTURE_RULE_NAME = "conjecture";
 export const DERIVATION_RULE_NAME = "derivation";
+export const HYPOTHESIS_RULE_NAME = "hypothesis";
 export const SUPPOSITION_RULE_NAME = "supposition";
 export const CONSTRUCTOR_RULE_NAME = "constructor";
 export const DECLARATION_RULE_NAME = "declaration";