occam-verify-cli 0.0.1092 → 0.0.1094

package/src/metavariable.js

@@ -2,12 +2,12 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import FrameForMetavariableSubstitution from "./substitution/frameForMetavariable";
-import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+import FrameSubstitution from "./substitution/frame";
+import StatementSubstitution from "./substitution/statement";
 
 import { nodeQuery } from "./utilities/query";
 import { EMPTY_STRING } from "./constants";
-import { metavariableNodeFromMetavariableString } from "./utilities/node";
+import { metavariableNodeFromMetavariableString } from "./nodeAndTokens/metavariable";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
 
@@ -101,8 +101,8 @@ class Metavariable {
       } else {
         const metavariable = this,  ///
               context = specificContext, ///
-              frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
-              substitution = frameForMetavariableSubstitution;  ///
+              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
+              substitution = frameSubstitution;  ///
 
         substitutions.addSubstitution(substitution, context);
 
@@ -131,7 +131,7 @@ class Metavariable {
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
           substitutionNode = (substitution !== null) ?
-                                substitution.getSubstitutionNode() :
+                                substitution.getNode() :
                                   null,
           substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
@@ -152,9 +152,9 @@ class Metavariable {
       } else {
         const context = specificContext, ///
               metavariable = this,  ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
+              statementSubstitution = StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
 
-        substitution = statementForMetavariableSubstitution;  ///
+        substitution = statementSubstitution;  ///
 
         substitutions.addSubstitution(substitution, context);
 
@@ -295,10 +295,9 @@ class Metavariable {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          lexer  = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          context = fileContext,  ///
           metavariableString = string,  ///
-          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, context),
           metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
           node = metavariableNode,  ///
           name = metavariableName,  ///

package/src/mixins/statement/qualified/unify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import StatementForMetavariableSubstitution from "../../../substitution/statementForMetavariable";
+import StatementSubstitution from "../../../substitution/statement";
 
 import { trim } from "../../../utilities/string";
 
@@ -44,8 +44,8 @@ function unifyAWithReference(qualifiedStatement, substitutions, context) {
     context.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
 
     const metavariable = reference.getMetavariable(),
-          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
-          substitution = statementForMetavariableSubstitution; ///
+          statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
+          substitution = statementSubstitution; ///
 
     substitutions.addSubstitution(substitution, context);
 
@@ -80,8 +80,8 @@ function unifyAWithAxiomLemmaTheoremOrConjecture(qualifiedStatement, substitutio
 
     if (statementUnified) {
       const metavariable = reference.getMetavariable(),
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
-            substitution = statementForMetavariableSubstitution; ///
+            statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
+            substitution = statementSubstitution; ///
 
       substitutions.addSubstitution(substitution, context);
 

package/src/mixins/statement/resolve.js

@@ -21,8 +21,8 @@ function resolveAsDefinedAssertion(statement, substitutions, generalContext, spe
 
     specificContext.trace(`Resolving the '${statementString}' statement as a defined assertion...`);
 
-    const localContext = specificContext, ///
-          definedAssertionVerified = definedAssertion.resolve(substitutions, localContext);
+    const context = specificContext,  ///
+          definedAssertionVerified = definedAssertion.resolve(substitutions, context);
 
     resolvedAsDefinedAssertion = definedAssertionVerified; ///
 
@@ -47,8 +47,8 @@ function resolveAsContainedAssertion(statement, substitutions, generalContext, s
 
     specificContext.trace(`Resolving the '${statementString}' statement as a contained assertion...`);
 
-    const localContext = specificContext, ///
-          containedAssertionVerified = containedAssertion.resolve(substitutions, localContext);
+    const context = specificContext,  ///
+          containedAssertionVerified = containedAssertion.resolve(substitutions, context);
 
     resolvedAsContainedAssertion = containedAssertionVerified; ///
 

package/src/nodeAndTokens/metavariable.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import NodeAndTokens from "../nodeAndTokens";
+
+import { ruleFromBNF } from "../nodeAndTokens";
+
+const bnf = `
+
+        _ ::= metavariable... <END_OF_LINE> ;
+        
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class MetavariableNodeAndTokens extends NodeAndTokens {
+  getMetavariableNode() {
+    const metavariableNode = this.node; ///
+
+    return metavariableNode;
+  }
+
+  getMetavariableTokens() {
+    const metavariableTokens = this.tokens; ///
+
+    return metavariableTokens;
+  }
+
+  static rule = rule;
+
+  static fromMetavariable(metavariable, context) {
+    const string = metavariable.getString(),
+          metavariableNodeAndTokens = NodeAndTokens.fromString(MetavariableNodeAndTokens, string, context);
+
+    return metavariableNodeAndTokens;
+  }
+
+  static fromMetavariableString(metavariableString, context) {
+    const string = metavariableString,  ///
+          metavariableNodeAndTokens = NodeAndTokens.fromString(MetavariableNodeAndTokens, string, context);
+
+    return metavariableNodeAndTokens;
+  }
+}
+
+export function metavariableNodeFromMetavariableString(metavariableString, context) {
+  const metavariableNodeAndTokens = MetavariableNodeAndTokens.fromMetavariableString(metavariableString, context),
+        metavariableNode = metavariableNodeAndTokens.getMetavariableNode();
+
+  return metavariableNode;
+}

package/src/nodeAndTokens/statement.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import NodeAndTokens from "../nodeAndTokens";
+
+import { ruleFromBNF } from "../nodeAndTokens";
+
+const bnf = `
+
+        _ ::= statement... <END_OF_LINE> ;
+        
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class StatementNodeAndTokens extends NodeAndTokens {
+  getStatementNode() {
+    const statementNode = this.node; ///
+
+    return statementNode;
+  }
+
+  getStatementTokens() {
+    const statementTokens = this.tokens; ///
+
+    return statementTokens;
+  }
+
+  static rule = rule;
+
+  static fromStatement(statement, context) {
+    const string = statement.getString(),
+          statementNodeAndTokens = NodeAndTokens.fromString(StatementNodeAndTokens, string, context);
+
+    return statementNodeAndTokens;
+  }
+
+  static fromStatementString(statementString, context) {
+    const string = statementString,  ///
+          statementNodeAndTokens = NodeAndTokens.fromString(StatementNodeAndTokens, string, context);
+
+    return statementNodeAndTokens;
+  }
+}
+
+export function statementNodeFromStatementString(statementString, context) {
+  const statementNodeAndTokens = StatementNodeAndTokens.fromStatementString(statementString, context),
+        statementNode = statementNodeAndTokens.getStatementNode();
+
+  return statementNode;
+}

package/src/nodeAndTokens/substitution/frame.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NodeAndTokens from "../../nodeAndTokens";
+
+import { ruleFromBNF } from "../../nodeAndTokens";
+
+const bnf = `
+
+            _ ::= frameSubstitution... <END_OF_LINE> ;
+            
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class FrameSubstitutionNodeAndTokens extends NodeAndTokens {
+  static rule = rule;
+
+  static fromFrameSubstitutionString(frameSubstitutionString, context) {
+    const string = frameSubstitutionString, ///
+          frameSubstitutionNodeAndTokens = NodeAndTokens.fromString(FrameSubstitutionNodeAndTokens, string, context);
+
+    return frameSubstitutionNodeAndTokens;
+  }
+}

package/src/nodeAndTokens/substitution/statement.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NodeAndTokens from "../../nodeAndTokens";
+
+import { ruleFromBNF } from "../../nodeAndTokens";
+
+const bnf = `
+
+            _ ::= statementSubstitution... <END_OF_LINE> ;
+            
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class StatementSubstitutionNodeAndTokens extends NodeAndTokens {
+  static rule = rule;
+
+  static fromStatementSubstitutionString(statementSubstitutionString, context) {
+    const string = statementSubstitutionString, ///
+          statementSubstitutionNodeAndTokens = NodeAndTokens.fromString(StatementSubstitutionNodeAndTokens, string, context);
+
+    return statementSubstitutionNodeAndTokens;
+  }
+}

package/src/nodeAndTokens/substitution/term.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NodeAndTokens from "../../nodeAndTokens";
+
+import { ruleFromBNF } from "../../nodeAndTokens";
+
+const bnf = `
+
+            _ ::= termSubstitution... <END_OF_LINE> ;
+            
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class TermSubstitutionNodeAndTokens extends NodeAndTokens {
+  static rule = rule;
+
+  static fromTermSubstitutionString(termSubstitutionString, context) {
+    const string = termSubstitutionString,  ///
+          termSubstitutionNodeAndTokens = NodeAndTokens.fromString(TermSubstitutionNodeAndTokens, string, context);
+
+    return termSubstitutionNodeAndTokens;
+  }
+}

package/src/nodeAndTokens/term.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import NodeAndTokens from "../nodeAndTokens";
+
+import { ruleFromBNF } from "../nodeAndTokens";
+
+const bnf = `
+
+        _ ::= term... <END_OF_LINE> ;
+        
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class TermNodeAndTokens extends NodeAndTokens {
+  getTermNode() {
+    const termNode = this.node; ///
+
+    return termNode;
+  }
+
+  getTermTokens() {
+    const termTokens = this.tokens; ///
+
+    return termTokens;
+  }
+
+  static rule = rule;
+
+  static fromTerm(term, context) {
+    const string = term.getString(),
+          termNodeAndTokens = NodeAndTokens.fromString(TermNodeAndTokens, string, context);
+
+    return termNodeAndTokens;
+  }
+
+  static fromTermString(termString, context) {
+    const string = termString,  ///
+          termNodeAndTokens = NodeAndTokens.fromString(TermNodeAndTokens, string, context);
+
+    return termNodeAndTokens;
+  }
+}
+
+export function termNodeFromTermString(termString, context) {
+  const termNodeAndTokens = TermNodeAndTokens.fromTermString(termString, context),
+        termNode = termNodeAndTokens.getTermNode();
+
+  return termNode;
+}

package/src/nodeAndTokens/variable.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import NodeAndTokens from "../nodeAndTokens";
+
+import { ruleFromBNF } from "../nodeAndTokens";
+
+const bnf = `
+
+        _ ::= variable... <END_OF_LINE> ;
+        
+      `,
+      rule = ruleFromBNF(bnf);
+
+export default class VariableNodeAndTokens extends NodeAndTokens {
+  getVariableNode() {
+    const variableNode = this.node; ///
+
+    return variableNode;
+  }
+
+  getVariableTokens() {
+    const variableTokens = this.tokens; ///
+
+    return variableTokens;
+  }
+
+  static rule = rule;
+
+  static fromVariable(variable, context) {
+    const string = variable.getString(),
+          variableNodeAndTokens = NodeAndTokens.fromString(VariableNodeAndTokens, string, context);
+
+    return variableNodeAndTokens;
+  }
+
+  static fromVariableString(variableString, context) {
+    const string = variableString,  ///
+          variableNodeAndTokens = NodeAndTokens.fromString(VariableNodeAndTokens, string, context);
+
+    return variableNodeAndTokens;
+  }
+}
+
+export function variableNodeFromVariableString(variableString, context) {
+  const variableNodeAndTokens = VariableNodeAndTokens.fromVariableString(variableString, context),
+        variableNode = variableNodeAndTokens.getVariableNode();
+
+  return variableNode;
+}

package/src/nodeAndTokens.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import { BNFLexer } from "occam-lexers";
+import { BNFParser } from "occam-parsers";
+import { arrayUtilities } from "necessary";
+
+import { nodeQuery } from "./utilities/query";
+
+const { first } = arrayUtilities;
+
+const bnfLexer = BNFLexer.fromNothing(),
+      bnfParser = BNFParser.fromNothing();
+
+const childNodeQuery = nodeQuery("/*/*!");
+
+export default class NodeAndTokens {
+  constructor(node, tokens) {
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  static fromString(Class, string, context) {
+    const { rule } = Class,
+          lexer = context.getLexer(),
+          parser = context.getParser(),
+          ruleMap = parser.getRuleMap(),
+          ruleName = rule.getName();
+
+    ruleMap[ruleName] = rule;
+
+    const startRule = rule, ///
+          content = `${string}
+`;
+
+    let tokens = lexer.tokenise(content),
+        node = parser.parse(tokens, startRule);
+
+    delete  ruleMap[ruleName];
+
+    const childNode = childNodeQuery(node);
+
+    node = childNode; ///
+
+    tokens = tokensFromTokensAndNode(tokens, node);  ///
+
+    const nodeAndTokens = new Class(node, tokens);
+
+    return nodeAndTokens;
+  }
+}
+
+export function ruleFromBNF(bnf) {
+  const tokens = bnfLexer.tokensFromBNF(bnf),
+        rules = bnfParser.rulesFromTokens(tokens),
+        firstRule = first(rules),
+        rule = firstRule; ///
+
+  return rule;
+}
+
+function tokensFromTokensAndNode(tokens, node) {
+  const lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  return tokens;
+}

package/src/statement/unqualified.js

@@ -30,7 +30,8 @@ class UnqualifiedStatement {
   verify(assignments, stated, context) {
     let verified;
 
-    const unqualifiedStatementString = this.getString(); ///
+    const unqualifiedStatement = this,  ///
+          unqualifiedStatementString = unqualifiedStatement.getString();  ///
 
     if (this.statement !== null) {
       context.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
@@ -61,7 +62,8 @@ class UnqualifiedStatement {
     let statementUnified;
 
     const statementString = statement.getString(),
-          unqualifiedStatementString = this.getString();  ///
+          unqualifiedStatement = this,  ///
+          unqualifiedStatementString = unqualifiedStatement.getString();  ///
 
     specificContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
 
@@ -77,7 +79,8 @@ class UnqualifiedStatement {
   resolveIndependently(substitutions, generalContext, specificContext) {
     let resolveIndependently;
 
-    const unqualifiedStatementString = this.getString();  ///
+    const unqualifiedStatement = this,  ///
+          unqualifiedStatementString = unqualifiedStatement.getString();  ///
 
     specificContext.trace(`Resolving the '${unqualifiedStatementString}' unqualified statement independently...`);
 

package/src/statement.js

@@ -6,14 +6,11 @@ import verifyMixins from "./mixins/statement/verify";
 import LocalContext from "./context/local";
 import resolveMixins from "./mixins/statement/resolve";
 import metaLevelUnifier from "./unifier/metaLevel";
+import StatementNodeAndTokens from "./nodeAndTokens/statement";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
-import { statementTokensFromUnqualifiedStatementTokens, unqualifiedStatementTokensFromUnqualifiedStatementString } from "./utilities/tokens";
-import { statementNodeFromUnqualifiedStatementNode,
-         unqualifiedStatementStringFromStatementString,
-         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/*//statement"),
       statementTermNodesQuery = nodesQuery("/statement//term"),
@@ -254,16 +251,11 @@ class Statement {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          context = fileContext,  ///
           statementString = string, ///
-          unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
-          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
-          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-          statementTokens = statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens),
-          statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
-          node = statementNode,  ///
-          tokens = statementTokens, ///
+          statementNodeAndTokens = StatementNodeAndTokens.fromStatementString(statementString, context),
+          node = statementNodeAndTokens.getNode(),
+          tokens = statementNodeAndTokens.getTokens(),
           statement = new Statement(string, node, tokens);
 
     return statement;

package/src/substitution/{frameForMetavariable.js → frame.js}

@@ -2,19 +2,15 @@
 
 import shim from "../shim";
 import Substitution from "../substitution";
+import FrameSubstitutionNodeAndTokens from "../nodeAndTokens/substitution/frame";
 
 import { nodeQuery } from "../utilities/query";
-import { substitutionNodeFromUnqualifiedStatementNode,
-         unqualifiedStatementStringFromSubstitutionString,
-         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
-import { unqualifiedStatementTokensFromUnqualifiedStatementString,
-         substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } from "../utilities/tokens";
 
-const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
-      metavariableNodeQuery = nodeQuery("/substitution/frame[1]/metavariable!"),
-      substitutionNodeQuery = nodeQuery("/statement/substitution");
+const frameNodeQuery = nodeQuery("/frameSubstitution/frame[0]"),
+      metavariableNodeQuery = nodeQuery("/frameSubstitution/frame[1]/metavariable!"),
+      frameSubstitutionNodeQuery = nodeQuery("/statement/frameSubstitution");
 
-export default class FrameForMetavariableSubstitution extends Substitution {
+export default class FrameSubstitution extends Substitution {
   constructor(string, node, tokens, frame, metavariable) {
     super(string, node, tokens);
 
@@ -87,44 +83,38 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   static fromStatementNode(statementNode, context) {
-    let frameForMetavariableSubstitution = null;
+    let frameSubstitution = null;
 
-    const substitutionNode = substitutionNodeQuery(statementNode);
+    const frameSubstitutionNode = frameSubstitutionNodeQuery(statementNode);
 
-    if (substitutionNode !== null) {
-      const frameNode = frameNodeQuery(substitutionNode),
-            metavariableNode = metavariableNodeQuery(substitutionNode);
+    if (frameSubstitutionNode !== null) {
+      const frameNode = frameNodeQuery(frameSubstitutionNode),
+            metavariableNode = metavariableNodeQuery(frameSubstitutionNode);
 
       if ((frameNode !== null) && (metavariableNode !== null)) {
         const { Frame, Metavariable } = shim,
               frame = Frame.fromFrameNode(frameNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
-              node = substitutionNode,  ///
+              node = frameSubstitutionNode,  ///
               tokens = context.nodeAsTokens(node),
               string = stringFromFrameAndMetavariable(frame, metavariable);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, node, tokens, frame, metavariable);
+        frameSubstitution = new FrameSubstitution(string, node, tokens, frame, metavariable);
       }
     }
 
-    return frameForMetavariableSubstitution;
+    return frameSubstitution;
   }
 
   static fromFrameAndMetavariable(frame, metavariable, context) {
-    const lexer = context.getLexer(),
-          parser = context.getParser(),
-          string = stringFromFrameAndMetavariable(frame, metavariable),
-          substitutionString = string,  ///
-          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
-          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
-          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
-          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
-          node = substitutionNode,  //
-          tokens = substitutionTokens,  ///
-          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, node, tokens, frame, metavariable);
-
-    return statementForMetavariableSubstitution;
+    const string = stringFromFrameAndMetavariable(frame, metavariable),
+          frameSubstitutionString = string,  ///
+          frameSubstitutionNodeAndTokens = FrameSubstitutionNodeAndTokens.fromFrameSubstitutionString(frameSubstitutionString, context),
+          node = frameSubstitutionNodeAndTokens.getNode(),
+          tokens = frameSubstitutionNodeAndTokens.getTokens(),
+          frameSubstitution = new FrameSubstitution(string, node, tokens, frame, metavariable);
+
+    return frameSubstitution;
   }
 }