occam-verify-cli 0.0.982 → 0.0.984

package/src/substitution/frameForMetavariable.js

@@ -0,0 +1,183 @@
+"use strict";
+
+import Substitution from "../substitution";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+
+import { nodeQuery } from "../utilities/query";
+import { stripBracketsFromFrame } from "../utilities/brackets";
+
+const frameNodeQuery = nodeQuery("/substitution/frame!"),
+      substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!"),
+      frameStatementMetavariableNodeQuery = nodeQuery("/frame/statement/metavariable!");
+
+export default class FrameForMetavariableSubstitution extends Substitution {
+  constructor(frameNode, metavariableNode, substitution) {
+    super();
+
+    this.frameNode = frameNode;
+    this.metavariableNode = metavariableNode;
+    this.substitution = substitution;
+  }
+
+  getFrameNode() {
+    return this.frameNode;
+  }
+
+  getMetavariableNode() {
+    return this.metavariableNode;
+  }
+
+  getSubstitution() {
+    return this.substitution;
+  }
+
+  getNode() {
+    const node = this.frameNode;  ///
+
+    return node;
+  }
+
+  isSimple() {
+    const simple = (this.substitution === null);
+
+    return simple;
+  }
+
+  transformed(substitutions) {
+    let transformedSubstitution = null;
+
+    const transformedFrameNode = transformFrameNode(this.frameNode, substitutions);
+
+    if (transformedFrameNode !== null) {
+      const substitution = null,
+            frameNode = transformedFrameNode, ///
+            metavariableNode = this.metavariableNode, ///
+            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
+
+      transformedSubstitution = frameForMetavariableSubstitution;  ///
+    }
+
+    return transformedSubstitution;
+  }
+
+  matchFrameNode(frameNode) {
+    frameNode = stripBracketsFromFrame(frameNode); ///
+
+    const frameNodeMatches = this.frameNode.match(frameNode);
+
+    return frameNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
+
+    return metavariableNodeAndSubstitutionNodeMatches;
+  }
+
+  asString(localContextA, localContextB) {
+    let string;
+
+    const frameNodeB = this.frameNode,  ///
+          frameStringB = localContextB.nodeAsString(frameNodeB),
+          metavariableNodeA = this.metavariableNode,  ///
+          metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+
+    if (this.substitution === null) {
+      string = `[${frameStringB} for ${metavariableStringA}]`;
+    } else {
+      const substitutionString = this.substitution.asString(localContextA, localContextA);
+
+      string = `[${frameStringB} for ${metavariableStringA}${substitutionString}]`;
+    }
+
+    return string;
+  }
+
+  static fromSubstitutionNode(substitutionNode) {
+    let frameForMetavariableSubstitution = null;
+
+    let frameNode = frameNodeQuery(substitutionNode);
+
+    if (frameNode !== null) {
+      frameNode = stripBracketsFromFrame(frameNode); ///
+
+      const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
+            metavariableNode = substitutionMetavariableNode,  ///
+            substitution = null;
+
+      frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
+    }
+
+    return frameForMetavariableSubstitution;
+  }
+
+  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode) {
+    frameNode = stripBracketsFromFrame(frameNode); ///
+
+    const substitution = null,
+          frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
+
+    return frameForMetavariableSubstitution;
+  }
+
+  static fromFrameNodeMetavariableNodeAndSubstitutionNode(frameNode, metavariableNode, substitutionNode) {
+    frameNode = stripBracketsFromFrame(frameNode); ///
+
+    const substitution = substitutionFromSubstitutionNode(substitutionNode),
+          frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
+
+    return frameForMetavariableSubstitution;
+  }
+}
+
+function substitutionFromSubstitutionNode(substitutionNode) {
+  let substitution = null;
+
+  if (substitution === null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+
+    if (termForVariableSubstitution !== null) {
+      substitution = termForVariableSubstitution; ///
+    }
+  }
+
+  if (substitution === null) {
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
+
+    if (frameForMetavariableSubstitution !== null) {
+      substitution = frameForMetavariableSubstitution;  ///
+    }
+  }
+
+  return substitution;
+}
+
+function transformFrameNode(frameNode, substitutions) {
+  let transformedFrameNode = null;
+
+  const frameStatementMetavariableNode = frameStatementMetavariableNodeQuery(frameNode);
+
+  if (frameStatementMetavariableNode !== null) {
+    const metavariableNode = frameStatementMetavariableNode;  ///
+
+    substitutions.someSubstitution((substitution) => {
+      const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
+
+      if (substitutionMatchesVariableNode) {
+        const frameNode = substitution.getFrameNode();
+
+        transformedFrameNode = frameNode; ////
+
+        return true;
+      }
+    });
+  }
+
+  return transformedFrameNode;
+}

package/src/substitution/statementForMetavariable.js

@@ -2,12 +2,12 @@
 
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "../substitution/termForVariable";
+import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
-const statementNodeQuery = nodeQuery("/substitution/statement!"),
-      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+const statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(statementNode, metavariableNode, substitution) {
@@ -98,23 +98,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return string;
   }
 
-  static fromSubstitutionNode(substitutionNode) {
-    let statementForMetavariableSubstitution = null;
-
-    let statementNode = statementNodeQuery(substitutionNode),
-        metavariableNode = metavariableNodeQuery(substitutionNode);
-
-    if (statementNode !== null) {
-      statementNode = stripBracketsFromStatement(statementNode); ///
-
-      const substitution = null;
-
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
-    }
-
-    return statementForMetavariableSubstitution;
-  }
-
   static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
@@ -146,10 +129,10 @@ function substitutionFromSubstitutionNode(substitutionNode) {
   }
 
   if (substitution === null) {
-    const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
 
-    if (statementForMetavariableSubstitution !== null) {
-      substitution = statementForMetavariableSubstitution;  ///
+    if (frameForMetavariableSubstitution !== null) {
+      substitution = frameForMetavariableSubstitution;  ///
     }
   }
 
@@ -159,9 +142,11 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 function transformStatementNode(statementNode, substitutions) {
   let transformedStatementNode = null;
 
-  const metavariableNode = metavariableNodeQuery(statementNode);
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode; ///
 
-  if (metavariableNode !== null) {
     substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
 

package/src/tokens/combinatorFrame/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { FRAME_META_TYPE_NAME } from "../../metaTypeNames";
+import { fromTokensFromFrameString } from "../../utilities/tokens";
+
+const bracketedCombinatorFrameString = `(${FRAME_META_TYPE_NAME})`;
+
+const bracketedCombinatorFrameTokens = fromTokensFromFrameString(bracketedCombinatorFrameString)
+
+export default bracketedCombinatorFrameTokens;

package/src/tokens/combinatorStatement/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
+import { statementTokensFromStatementString } from "../../utilities/tokens";
+
+const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+const bracketedCombinatorStatementTokens = statementTokensFromStatementString(bracketedCombinatorStatementString)
+
+export default bracketedCombinatorStatementTokens;

package/src/tokens/constructorTerm/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../typeNames";
+import { termTokensFromTermString } from "../../utilities/tokens";
+
+const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME})`;
+
+const bracketedConstructorDeclarationTokens = termTokensFromTermString(bracketedConstructorTermString)
+
+export default bracketedConstructorDeclarationTokens;

package/src/utilities/brackets.js

@@ -1,10 +1,11 @@
 "use strict";
 
 import bracketedTermNode from "../node/term/bracketed";
+import bracketedFrameNode from "../node/frame/bracketed";
 import bracketedStatementNode from "../node/statement/bracketed";
 
 import { nodeQuery } from "../utilities/query";
-import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
+import { BRACKETED_TERM_DEPTH, BRACKETED_FRAME_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
 const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
       bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
@@ -19,6 +20,16 @@ export function stripBracketsFromTerm(statementNode) {
   return statementNode;
 }
 
+export function stripBracketsFromFrame(frameNode) {
+  const bracketedFrameChildNode = bracketedFrameChildNodeFromFrameNode(frameNode);
+
+  if (bracketedFrameChildNode !== null) {
+    frameNode = bracketedFrameChildNode;  ///
+  }
+
+  return frameNode;
+}
+
 export function stripBracketsFromStatement(statementNode) {
   const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
@@ -42,6 +53,19 @@ function bracketedTermChildNodeFromTermNode(termNode) {
   return bracketedTermChildNode;
 }
 
+function bracketedFrameChildNodeFromFrameNode(frameNode) {
+  let bracketedFrameChildNode = null;
+
+  const depth = BRACKETED_FRAME_DEPTH,
+        frameNodeMatchBracketedFrameNode = frameNode.match(bracketedFrameNode, depth);
+
+  if (frameNodeMatchBracketedFrameNode) {
+    bracketedFrameChildNode = bracketedFrameChildNodeQuery(frameNode);
+  }
+
+  return bracketedFrameChildNode;
+}
+
 function bracketedStatementChildNodeFromStatementNode(statementNode) {
   let bracketedStatementChildNode = null;
 

package/src/utilities/node.js

@@ -2,59 +2,58 @@
 
 import { parsersUtilities } from "occam-custom-grammars";
 
-import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { constructorDeclarationTokensFromTermString, unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import { termTokensFromTermString, frameTokensFromFrameString, statementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
-
 export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, lexer),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
+  const termTokens = termTokensFromTermString(termString, lexer),
+        termNode = termNodeFromTermTokens(termTokens, parser);
 
   return termNode;
 }
 
-export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
-        statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+export function frameNodeFromFrameString(frameString, lexer, parser) {
+  const frameTokens = frameTokensFromFrameString(frameString, lexer),
+        frameNode = frameNodeFromFrameTokens(frameTokens, parser);
 
-  return statementNode;
+  return frameNode;
 }
 
-export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
-        termNode = termNodeQuery(constructorDeclarationNode);
+export function statementNodeFromStatementString(statementString, lexer, parser) {
+  const statementTokens = statementTokensFromStatementString(statementString, lexer),
+        statementNode = statementNodeFromStatementTokens(statementTokens, parser);
 
-  return termNode;
+  return statementNode;
 }
 
-export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+export function termNodeFromTermTokens(termTokens, parser) {
+  const tokens = termTokens,  ///
+        ruleName = TERM_RULE_NAME,
+        termNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return statementNode;
+  return termNode;
 }
 
-function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);
+export function frameNodeFromFrameTokens(frameTokens, parser) {
+  const tokens = frameTokens,  ///
+        ruleName = FRAME_RULE_NAME,
+        frameNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return unqualifiedStatementNode;
+  return frameNode;
 }
 
-function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
-        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
+export function statementNodeFromStatementTokens(statementTokens, parser) {
+  const tokens = statementTokens,  ///
+        ruleName = STATEMENT_RULE_NAME,
+        statementNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return constructorDeclarationNode;
+  return statementNode;
 }
 
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {

package/src/utilities/tokens.js

@@ -9,20 +9,25 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function constructorDeclarationTokensFromTermString(termString, lexer) {
-  const constructorDeclarationContent = `Constructor ${termString}
-`,
-        constructorDeclarationTokens = tokensFromContentAndLexer(constructorDeclarationContent, lexer);
+export function termTokensFromTermString(termString, lexer) {
+  const content = termString, ///
+        termTokens = tokensFromContentAndLexer(content, lexer);
 
-  return constructorDeclarationTokens;
+  return termTokens;
 }
 
-export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
-  const unqualifiedStatementContent = `${statementString}
-`,
-        unqualifiedStatementTokens = tokensFromContentAndLexer(unqualifiedStatementContent, lexer);
+export function frameTokensFromFrameString(frameString, lexer) {
+  const content = frameString,  ///
+        frameTokens = tokensFromContentAndLexer(content, lexer);
 
-  return unqualifiedStatementTokens;
+  return frameTokens;
+}
+
+export function statementTokensFromStatementString(statementString, lexer) {
+  const content = statementString,  ///
+        statementTokens = tokensFromContentAndLexer(content, lexer);
+
+  return statementTokens;
 }
 
 function tokensFromContentAndLexer(content, lexer = florenceLexer) {

package/src/verify/assertion/contained.js

@@ -6,9 +6,9 @@ import { isAssertionNegated } from "../../utilities/assertion";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metavariableNodeQuery = nodeQuery("/containedAssertion/statement[0]/metavariable"),
-      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//variable"),
-      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//metavariable");
+      metavariableNodeQuery = nodeQuery("/containedAssertion/frame/statement!/metavariable!"),
+      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement//metavariable");
 
 const verifyContainedAssertionFunctions = [
   verifyDerivedContainedAssertion,
@@ -56,53 +56,56 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, st
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`, containedAssertionNode);
 
-    const assertionNegated = isAssertionNegated(containedAssertionNode),
-          metavariableNode = metavariableNodeQuery(containedAssertionNode),
-          variableNode = variableNodeQuery(containedAssertionNode),
-          negated = assertionNegated; ///
-
-    if (false) {
-      ///
-    } else if (metavariableNode !== null) {
-      const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
-              const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
-
-              if (variableNodeMatchesStatementMetavariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+    const metavariableNode = metavariableNodeQuery(containedAssertionNode);
+
+    if (metavariableNode !== null) {
+      const assertionNegated = isAssertionNegated(containedAssertionNode),
+            variableNode = variableNodeQuery(containedAssertionNode),
+            negated = assertionNegated; ///
+
+      if (false) {
+        ///
+      } else if (metavariableNode !== null) {
+        const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
+                const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+
+                if (variableNodeMatchesStatementMetavariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
-    } else if (variableNode !== null) {
-      const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
-              const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
-
-              if (variableNodeMatchesStatementVariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+      } else if (variableNode !== null) {
+        const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+                const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+                if (variableNodeMatchesStatementVariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
       }
     }