occam-verify-cli 0.0.957 → 0.0.959

package/src/topLevelAssertion.js

@@ -1,8 +1,5 @@
 "use strict";
 
-import Label from "./label";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import Substitutions from "./substitutions";
 import unifyConsequentAgainstStatement from "./unify/consequentAgainstStatement";
 import unifySuppositionsAgainstProofSteps from "./unify/suppositionsAgainstProofSteps";
@@ -69,70 +66,5 @@ export default class TopLevelAssertion {
     return matchesMetavariableNode;
   }
 
-  toJSON(tokens) {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON(tokens);
-
-            return labelJSON;
-          }),
-          suppositionsJSON = this.suppositions.map((supposition) => {
-            const suppositionJSON = supposition.toJSON(tokens);
-
-            return suppositionJSON;
-          }),
-          consequentJSON = this.consequent.toJSON(tokens),
-          substitutionsJSON = this.substitutions.toJSON(tokens),
-          labels = labelsJSON,  ///
-          suppositions = suppositionsJSON,  ///
-          consequent = consequentJSON,  ///
-          substitutions = substitutionsJSON,  ///
-          json = {
-            labels,
-            suppositions,
-            consequent,
-            substitutions
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(Class, json, fileContext) {
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSONAndFileContext(json, fileContext);
-
-      return label;
-    });
-
-    let { suppositions, consequent, substitutions } = json;
-
-    const suppositionsJSON = suppositions;  ///
-
-    suppositions = suppositionsJSON.map((suppositionJSON) => {
-      const json = suppositionJSON, ///
-            supposition = Supposition.fromJSONAndFileContext(json, fileContext);
-
-      return supposition;
-    });
-
-    const consequentJSON = consequent;  ///
-
-    json = consequentJSON;  ///
-
-    consequent = Consequent.fromJSONAndFileContext(json, fileContext);
-
-    const substitutionsJSON = substitutions;  ///
-
-    json = substitutionsJSON; ///
-
-    substitutions = Substitutions.fromJSONAndFileContext(json, fileContext);
-
-    return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
-  }
-
   static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/type.js

@@ -125,18 +125,6 @@ export default class Type {
     return string;
   }
 
-  toJSON(tokens) {
-    const superTypeJSON = this.superType.toJSON(tokens),
-          name = this.name,
-          superType = superTypeJSON,  ///
-          json = {
-            name,
-            superType
-          };
-
-    return json;
-  }
-
   static fromTypeName(typeName) {
     const name = typeName,  ///
           superType = objectType, ///
@@ -154,17 +142,6 @@ export default class Type {
 }
 
 class ObjectType extends Type {
-  toJSON(tokens) {
-    const name = this.name,
-          superType = null,  ///
-          json = {
-            name,
-            superType
-          };
-
-    return json;
-  }
-
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,
           superType = null,
@@ -175,24 +152,3 @@ class ObjectType extends Type {
 }
 
 export const objectType = ObjectType.fromNothing();
-
-export function typeFromJSONAndFileContext(json, fileContext) {
-  let type;
-
-  const { name } = json,
-        typeName = name;  ///
-
-  type = fileContext.findTypeByTypeName(typeName);
-
-  if (type === null) {
-    let { superType } = json;
-
-    const superJSON = superType;  ///
-
-    superType = typeFromJSONAndFileContext(superJSON, fileContext);
-
-    type = new Type(name, superType);
-  }
-
-  return type;
-}

package/src/utilities/node.js

@@ -4,13 +4,8 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { METAVARIABLE_RULE_NAME,
-         VARIABLE_DECLARATION_RULE_NAME,
-         UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { metavariableTokensFromMetavariableString,
-         variableDeclarationTokensFromVariableString,
-         unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -18,16 +13,8 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export function variableNodeFromVariableString(variableString, lexer, parser) {
-  const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
-        variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
-
-  return variableNode;
-}
-
 export function statementNodeFromStatementString(statementString, lexer, parser) {
   const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
         statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
@@ -35,13 +22,6 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
-export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
-        metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
-
-  return metavariableNode;
-}
-
 export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   let termNode = null;
 
@@ -66,32 +46,6 @@ export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatement
   return statementNode;
 }
 
-export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  let variableNode = null;
-
-  const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser);
-
-  if (variableDeclarationNode !== null) {
-    variableNode = variableNodeQuery(variableDeclarationNode);
-  }
-
-  return variableNode;
-}
-
-export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
-
-  return metavariableNode;
-}
-
-export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  const ruleName = VARIABLE_DECLARATION_RULE_NAME,
-        variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
-
-  return variableDeclarationNode;
-}
-
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
         unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);

package/src/utilities/tokens.js

@@ -9,13 +9,6 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function metavariableTokensFromMetavariableString(metavariableString, lexer) {
-  const metavariableContent = `${metavariableString}`,
-        metavariableTokens = tokensFromContentAndLexer(metavariableContent, lexer);
-
-  return metavariableTokens;
-}
-
 export function constructorDeclarationTokensFromTermString(termString, lexer) {
   const constructorDeclarationContent = `Constructor ${termString}
 `,
@@ -24,14 +17,6 @@ export function constructorDeclarationTokensFromTermString(termString, lexer) {
   return constructorDeclarationTokens;
 }
 
-export function variableDeclarationTokensFromVariableString(variableString, lexer) {
-  const variableDeclarationContent = `Variable ${variableString}
-`,
-        variableDeclarationTokens = tokensFromContentAndLexer(variableDeclarationContent, lexer);
-
-  return variableDeclarationTokens;
-}
-
 export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
   const unqualifiedStatementContent = `${statementString}
 `,

package/src/variable.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { typeFromJSONAndFileContext } from "./type";
-import { variableNodeFromVariableString } from "./utilities/node";
 
 export default class Variable {
   constructor(node, type) {
@@ -58,40 +56,6 @@ export default class Variable {
     return string;
   }
 
-  toJSON(tokens) {
-    const typeJSON = this.type.toJSON(tokens),
-          string = nodeAsString(this.node, tokens),
-          node = string,  //
-          type = typeJSON,  ///
-          json = {
-            node,
-            type
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    let { node } = json;
-
-    const lexer  = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          variableString = node,  ///
-          variableNode = variableNodeFromVariableString(variableString, lexer, parser);
-
-    node = variableNode;  ///
-
-    let { type } = json;
-
-    json = type;  ///
-
-    type = typeFromJSONAndFileContext(json, fileContext);
-
-    const variable = new Variable(node, type);
-
-    return variable;
-  }
-
   static fromVariableAndType(variable, type) {
     const node = variable.getNode();
 

package/src/verify/assertion/type.js

@@ -115,43 +115,43 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
       const typeString = localContext.nodeAsString(typeNode);
 
       localContext.debug(`The '${typeString}' type is not present.`, typeNode);
-    }
+    } else {
+      const terms = [],
+            termNode = termNodeQuery(typeAssertionNode),
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              let verifiedAhead = false;
 
-    const terms = [],
-          termNode = termNodeQuery(typeAssertionNode),
-          termVerified = verifyTerm(termNode, terms, localContext, () => {
-            let verifiedAhead = false;
+              const firstTerm = first(terms),
+                    term = firstTerm, ///
+                    termType = term.getType(),
+                    typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
 
-            const firstTerm = first(terms),
-                  term = firstTerm, ///
-                  termType = term.getType(),
-                  typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
+              if (typeEqualToOrSubTypeOfTermType) {
+                const variableNode = variableNodeQuery(termNode);
 
-            if (typeEqualToOrSubTypeOfTermType) {
-              const variableNode = variableNodeQuery(termNode);
+                if (variableNode === null) {
+                  verifiedAhead = true;
+                } else {
+                  let variable;
 
-              if (variableNode === null) {
-                verifiedAhead = true;
-              } else {
-                let variable;
+                  variable = localContext.findVariableByVariableNode(variableNode);
 
-                variable = localContext.findVariableByVariableNode(variableNode);
-
-                variable = Variable.fromVariableAndType(variable, type);  ///
+                  variable = Variable.fromVariableAndType(variable, type);  ///
 
-                const variableAssignment = VariableAssignment.fromVariable(variable),
-                      assignment = variableAssignment;  ///
+                  const variableAssignment = VariableAssignment.fromVariable(variable),
+                        assignment = variableAssignment;  ///
 
-                assignments.push(assignment);
+                  assignments.push(assignment);
 
-                verifiedAhead = true;
+                  verifiedAhead = true;
+                }
               }
-            }
 
-            return verifiedAhead;
-          });
+              return verifiedAhead;
+            });
 
-    statedTypeAssertionVerified = termVerified; ///
+      statedTypeAssertionVerified = termVerified; ///
+    }
 
     if (statedTypeAssertionVerified) {
       localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);