occam-verify-cli 0.0.942 → 0.0.943

package/src/unify/premiseAgainstProofStep.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { subproofNodeAsSubproofString } from "../utilities/unify";
+
+export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
+  let premiseUnified = false;
+
+  const premiseAStatementNode = premiseA.getStatementNode();
+
+  if (premiseAStatementNode !== null) {
+    const proofStepBSubproofNode = proofStepB.getSubproofNode(),
+          proofStepBStatementNode = proofStepB.getStatementNode(),
+          subproofNodeB = proofStepBSubproofNode, ///
+          statementNodeB = proofStepBStatementNode, ///
+          statementNodeA = premiseAStatementNode, ///
+          statementStringA = localContextA.nodeAsString(statementNodeA)
+
+    substitutions.snapshot();
+
+    if (subproofNodeB !== null) {
+      const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
+
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement...`, subproofNodeB);
+
+      const subproofUnified = premiseA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
+
+      if (subproofUnified) {
+        localContextB.debug(`...unified the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement.`, subproofNodeB);
+
+        premiseUnified = true;
+      }
+    }
+
+    if (statementNodeB !== null) {
+      const statementStringB = localContextB.nodeAsString(statementNodeB);
+
+      localContextB.trace(`Unifying the '${statementStringB}' statement against the premise's '${statementStringA}' statement...`, statementNodeB);
+
+      const statementUnified = premiseA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+      if (statementUnified) {
+        localContextB.debug(`...unified the '${statementStringB}' statement against the premise's '${statementStringA}' statement.`, statementNodeB);
+
+        premiseUnified = true;
+      }
+    }
+
+    premiseUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+  }
+
+  return premiseUnified;
+}

package/src/unify/premisesAgainstProofSteps.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import unifyPremiseAgainstProofStep from "../unify/premiseAgainstProofStep";
+
+import { reverse, correlate } from "../utilities/array";
+
+export default function unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
+  premisesA = reverse(premisesA); ///
+
+  proofStepsB = reverse(proofStepsB); ///
+
+  const premisesUnified = correlate(premisesA, proofStepsB, (premiseA, proofStepB) => {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          premiseUnified = unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
+
+    if (premiseUnified) {
+      return true;
+    }
+  });
+
+  return premisesUnified;
+}

package/src/unify/statementAgainstMetaType.js

@@ -7,27 +7,19 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead) {
+export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext) {
   let statementVerifiedAgainstMetaType = false;
 
-  const metaTypeNode = metaTypeNodeB, ///
-        metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         content = metaTypeTerminalNode.getContent();
 
   if (content === STATEMENT_META_TYPE_NAME) {
-    let unifiedAhead = false;
-
     const { verifyStatement } = shim,
           derived = false,
           assignments = [],
-          statementNode = statementNodeA, ///
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    if (statementVerified) {
-      unifiedAhead = unifyAhead();
-    }
-
-    statementVerifiedAgainstMetaType = unifiedAhead; ///
+    statementVerifiedAgainstMetaType = statementVerified;
   }
 
   return statementVerifiedAgainstMetaType;

package/src/unify/suppositionAgainstProofStep.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { subproofNodeAsSubproofString } from "../utilities/unify";
+
+export default function unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
+  let suppositionUnified = false;
+
+  const suppositionAStatementNode = suppositionA.getStatementNode();
+
+  if (suppositionAStatementNode !== null) {
+    const proofStepBSubproofNode = proofStepB.getSubproofNode(),
+          proofStepBStatementNode = proofStepB.getStatementNode(),
+          subproofNodeB = proofStepBSubproofNode, ///
+          statementNodeB = proofStepBStatementNode, ///
+          statementNodeA = suppositionAStatementNode, ///
+          statementStringA = localContextA.nodeAsString(statementNodeA)
+
+    substitutions.snapshot();
+
+    if (subproofNodeB !== null) {
+      const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
+
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement...`, subproofNodeB);
+
+      const subproofUnified = suppositionA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
+
+      if (subproofUnified) {
+        localContextB.debug(`...unified the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement.`, subproofNodeB);
+
+        suppositionUnified = true;
+      }
+    }
+
+    if (statementNodeB !== null) {
+      const statementStringB = localContextB.nodeAsString(statementNodeB);
+
+      localContextB.trace(`Unifying the '${statementStringB}' statement against the supposition's '${statementStringA}' statement...`, statementNodeB);
+
+      const statementUnified = suppositionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
+
+      if (statementUnified) {
+        localContextB.debug(`...unified the '${statementStringB}' statement against the supposition's '${statementStringA}' statement.`, statementNodeB);
+
+        suppositionUnified = true;
+      }
+    }
+
+    suppositionUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContextA, localContextB);
+  }
+
+  return suppositionUnified;
+}

package/src/unify/suppositionsAgainstProofSteps.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import unifySuppositionAgainstProofStep from "./suppositionAgainstProofStep";
+
+import { reverse, correlate } from "../utilities/array";
+
+export default function unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
+  suppositionsA = reverse(suppositionsA); ///
+
+  proofStepsB = reverse(proofStepsB); ///
+
+  const suppositionsUnified = correlate(suppositionsA, proofStepsB, (suppositionA, proofStepB) => {
+    const localContextA = LocalContext.fromFileContext(fileContextA),
+          suppositionUnified = unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
+
+    if (suppositionUnified) {
+      return true;
+    }
+  });
+
+  return suppositionsUnified;
+}

package/src/unify/termAgainstTerm.js

@@ -2,18 +2,14 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function unifyTermAgainstTerm(termNodeA, termNodeB, localContext, unifyAhead) {
+export default function unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext) {
   let termUnifiedAgainstTerm = false;
 
-  const leftTermNode = termNodeA, ///
-        rightTermNode = termNodeB,  ///
-        equivalences = localContext.getEquivalences(),
+  const equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    const unifiedAhead = unifyAhead();
-
-    termUnifiedAgainstTerm = unifiedAhead;  ///
+    termUnifiedAgainstTerm = true;
   }
 
   return termUnifiedAgainstTerm;

package/src/unify/termAgainstType.js

@@ -4,26 +4,25 @@ import shim from "../shim";
 
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead) {
+export default function unifyTermAgainstType(termNode, typeNode, localContext) {
   let termUnifiedAgainstType;
 
   const { verifyTerm } = shim,
         terms = [],
-        termVerified = verifyTerm(termNodeA, terms, localContext, () => {
-          let unifiedAhead = false;
+        termVerified = verifyTerm(termNode, terms, localContext, () => {
+          let verifiedAhead = false;
 
           const firstTerm = first(terms),
                 term = firstTerm, ///
                 termType = term.getType(),
-                typeNode = typeNodeB, ///
                 type = localContext.findTypeByTypeNode(typeNode),
                 termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
           if (termTypeEqualToOrSubTypeOfType) {
-            unifiedAhead = unifyAhead();
+            verifiedAhead = true;
           }
 
-          return unifiedAhead;
+          return verifiedAhead;
         });
 
   termUnifiedAgainstType = termVerified; ///

package/src/unify/variableAgainstTerm.js

@@ -1,14 +1,12 @@
 "use strict";
 
-import verifyTerm from "../verify/term";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
-import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
   let variableUnifiedAgainstTerm = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
@@ -23,66 +21,38 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
     const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
     if (substitutionMatchesTermNodeB) {
-      const verifiedAhead = verifyAhead();
-
-      variableUnifiedAgainstTerm = verifiedAhead;  ///
+      variableUnifiedAgainstTerm = true;
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
 
     if (variableA !== null) {
-      const terms = [],
-            termUnified = verifyTerm(termNodeB, terms, localContextB, () => {
-              let verifiedAhead = false;
-
-              const firstTerm = first(terms),
-                    termB = firstTerm, ///
-                    variableB = variableFromTerm(termB, localContextB);
-
-              if (variableA === variableB) {
-                verifiedAhead = verifyAhead();
-              } else {
-                const term = termB, ///
-                      variable = variableA, ///
-                      termType = term.getType(),
-                      variableType = variable.getType(),
-                      variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
-
-                if (variableTypeEqualToOrSuperTypeOfTermType) {
-                  const termNode = termNodeB, ///
-                        variableNode = variableNodeA, ///
-                        termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-                        substitution = termForVariableSubstitution;  ///
-
-                  substitutions.addSubstitution(substitution);
-
-                  verifiedAhead = verifyAhead();
-
-                  if (!verifiedAhead) {
-                    substitutions.removeSubstitution(substitution);
-                  }
-                }
-              }
-
-              return verifiedAhead;
-            });
-
-      variableUnifiedAgainstTerm = termUnified;  ///
+      const variableB = variableFromTermNode(termNodeB, localContextB);
+
+      if (variableA !== variableB) {
+        const termNode = termNodeB, ///
+              variableNode = variableNodeA, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+              substitution = termForVariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContextA, localContextB);
+      }
+
+      variableUnifiedAgainstTerm = true;
     }
   }
 
   return variableUnifiedAgainstTerm;
 }
 
-function variableFromTerm(term, localContext) {
+function variableFromTermNode(termNode, localContext) {
   let variable = null;
 
-  const termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
+  const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
     variable = localContext.findVariableByVariableNode(variableNode);
   }
 
   return variable;
-}
+}

package/src/utilities/arguments.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { last } from "./array";
+import { FUNCTION } from "../constants";
+
+export function isLastRemainingArgumentFunction(remainingArguments) {
+  let lastRemainingArgumentFunction = false;
+
+  const remainingArgumentsLength = remainingArguments.length;
+
+  if (remainingArgumentsLength > 0) {
+    const lastRemainingArgument = last(remainingArguments);
+
+    lastRemainingArgumentFunction = (typeof lastRemainingArgument === FUNCTION);
+  }
+
+  return lastRemainingArgumentFunction;
+}

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, second, last, extract, push, match, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, extract, push, match, prune, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///

package/src/utilities/unify.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { nodeQuery, nodesQuery } from "./query";
+import { nodeAsString, nodesAsString } from "./string";
+
+const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+
+export function subproofNodeAsSubproofString(subproofNode, localContext) {
+  const tokens = localContext.getTokens(),
+        subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+        subproofSuppositionStatementsString = nodesAsString(subproofSuppositionStatementNodes, tokens),
+        subproofLastProofStepStatementString = nodeAsString(subproofLastProofStepStatementNode, tokens),
+        subproofString = `[${subproofSuppositionStatementsString}]...${subproofLastProofStepStatementString}`;
+
+  return subproofString;
+}

package/src/verifier/metaLevel.js

@@ -16,11 +16,7 @@ class MetaLevelVerifier extends Verifier {
     let verified;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext);
 
     verified = nonTerminalNodeVerified;  ///
 
@@ -30,25 +26,25 @@ class MetaLevelVerifier extends Verifier {
   static maps = [
     {
       nodeQuery: metavariableNodeQuery,
-      verify: (metavariableNode, localContext, verifyAhead) => {
-        const metavariableVerified = verifyMetavariable(metavariableNode, localContext, verifyAhead);
+      verify: (metavariableNode, localContext) => {
+        const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
         return metavariableVerified;
       }
     },
     {
       nodeQuery: variableNodeQuery,
-      verify: (variableNode, localContext, verifyAhead) => {
-        const variableVerified = verifyVariable(variableNode, localContext, verifyAhead);
+      verify: (variableNode, localContext) => {
+        const variableVerified = verifyVariable(variableNode, localContext);
 
         return variableVerified;
       }
     },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext, verifyAhead) => {
+      verify: (termNode, localContext) => {
         const terms = [],
-              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+              termVerified = verifyTerm(termNode, terms, localContext);
 
         return termVerified;
       }

package/src/verifier/statementAsCombinator.js

@@ -17,11 +17,7 @@ class StatementAsCombinatorVerifier extends Verifier {
 
     const nonTerminalNode = statementNode, ///
           childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext);
 
     statementVerifiedAsCombinator = childNodesVerified;  ///
 
@@ -29,41 +25,32 @@ class StatementAsCombinatorVerifier extends Verifier {
   }
 
   static maps = [
+    {
+      nodeQuery: statementNodeQuery,
+      verify: (statementNode, localContext) => {
+        const derived = false,
+              assignments = [],
+              statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+
+        return statementVerified;
+      }
+    },
     {
       nodeQuery: termNodeQuery,
-      verify: (termNode, localContext, verifyAhead) => {
+      verify: (termNode, localContext) => {
         const terms = [],
-              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+              termVerified = verifyTerm(termNode, terms, localContext);
 
         return termVerified;
       }
     },
     {
       nodeQuery: typeNodeQuery,
-      verify: (typeNode, localContext, verifyAhead) => {
-        const typeVerified = verifyType(typeNode, localContext, verifyAhead);
+      verify: (typeNode, localContext) => {
+        const typeVerified = verifyType(typeNode, localContext);
 
         return typeVerified;
       }
-    },
-    {
-      nodeQuery: statementNodeQuery,
-      verify: (statementNode, localContext, verifyAhead) => {
-        let statementVerified;
-
-        const derived = false,
-              assignments = [];
-
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
-
-        if (statementVerified) {
-          const verifiedAhead = verifyAhead();
-
-          statementVerified = verifiedAhead;  ///
-        }
-
-        return statementVerified;
-      }
     }
   ];
 }

package/src/verifier/topLevel.js

@@ -18,29 +18,25 @@ import verifyMetavariableDeclaration from "../verify/declaration/metavariable";
 import { nodeQuery } from "../utilities/query";
 
 const errorNodeQuery = nodeQuery("/error"),
-      ruleNodeQuery = nodeQuery("/rule!"),
-      axiomNodeQuery = nodeQuery("/axiom!"),
-      lemmaNodeQuery = nodeQuery("/lemma!"),
-      theoremNodeQuery = nodeQuery("/theorem!"),
-      metaLemmaNodeQuery = nodeQuery("/metaLemma!"),
-      conjectureNodeQuery = nodeQuery("/conjecture!"),
-      metatheoremNodeQuery = nodeQuery("/metatheorem!"),
-      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration!"),
-      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration!"),
-      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration!"),
-      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration!"),
-      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration!");
+      ruleNodeQuery = nodeQuery("/rule"),
+      axiomNodeQuery = nodeQuery("/axiom"),
+      lemmaNodeQuery = nodeQuery("/lemma"),
+      theoremNodeQuery = nodeQuery("/theorem"),
+      metaLemmaNodeQuery = nodeQuery("/metaLemma"),
+      conjectureNodeQuery = nodeQuery("/conjecture"),
+      metatheoremNodeQuery = nodeQuery("/metatheorem"),
+      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration"),
+      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
+      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration"),
+      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration"),
+      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration");
 
 class TopLevelVerifier extends Verifier {
   verify(node, fileContext) {
     let verified;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext);
 
     verified = nonTerminalNodeVerified;  ///
 

package/src/verifier.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
+import { isLastRemainingArgumentFunction } from "./utilities/arguments";
 
 const nonTerminalNodeQuery = nodeQuery("/*");
 
@@ -38,10 +39,23 @@ export default class Verifier {
   verifyChildNodes(childNodes, ...remainingArguments) {
     let childNodesVerify;
 
-    const index = 0,
-          childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
-    childNodesVerify = childNodesVerifyAhead; ///
+    if (lastRemainingArgumentFunction) {
+      const index = 0,
+            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+
+      childNodesVerify = childNodesVerifyAhead; ///
+    } else {
+      childNodesVerify = childNodes.every((childNode) => {
+        const node = childNode,
+              nodeVerified = this.verifyNode(node, ...remainingArguments);
+
+        if (nodeVerified) {
+          return true;
+        }
+      });
+    }
 
     return childNodesVerify;
   }
@@ -49,10 +63,18 @@ export default class Verifier {
   verifyTerminalNode(terminalNode, ...remainingArguments) {
     let terminalNodeVerified;
 
-    const verifyAhead = remainingArguments.pop(), ///
-          verifiedAhead = verifyAhead();  ///
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+
+    if (lastRemainingArgumentFunction) {
+      const verifyAhead = remainingArguments.pop(), ///
+            verifiedAhead = verifyAhead();
+
+      terminalNodeVerified = verifiedAhead; ///
 
-    terminalNodeVerified = verifiedAhead; ///
+      remainingArguments.push(verifyAhead);
+    } else {
+      terminalNodeVerified = true;
+    }
 
     return terminalNodeVerified;
   }

package/src/verify/assertion/type.js

@@ -77,9 +77,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
 
                   verifiedAhead = true;
 
-                  if (!verifiedAhead) {
-                    assignments.pop();
-                  }
+                  assignments.pop();
                 }
               }
             }
@@ -136,9 +134,7 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
 
                   verifiedAhead = true;
 
-                  if (!verifiedAhead) {
-                    assignments.pop();
-                  }
+                  assignments.pop();
                 }
               }
             }

package/src/verify/declaration/metavariable.js

@@ -47,14 +47,14 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
     fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
     const termTypes = [],
-      metaTypes = [],
-      argumentNode = argumentNodeQuery(metavariableNode),
-      argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
-      metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
+          metaTypes = [],
+          argumentNode = argumentNodeQuery(metavariableNode),
+          argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
+          metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
 
     if (argumentVerified && metaTypeVerified) {
       let termType,
-        metaType;
+          metaType;
 
       const firstMetaType = first(metaTypes);
 
@@ -71,10 +71,10 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
       }
 
       const node = metavariableNode,  ///
-        name = nameFromMetavariableNode(metavariableNode),
-        metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
-        metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
-        metavariableAssigned = metavariableAssignment.assign(fileContext);
+            name = nameFromMetavariableNode(metavariableNode),
+            metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
+            metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+            metavariableAssigned = metavariableAssignment.assign(fileContext);
 
       if (metavariableAssigned) {
         metavariableVerified = true;