occam-verify-cli 0.0.978 → 0.0.979

package/src/rule.js

@@ -29,16 +29,6 @@ export default class Rule {
     return this.fileContext;
   }
 
-  getLabelMetavariableNodes() {
-    const labelMetavariableNodes = this.labels.map((label) => {
-      const labelMetavariableNode = label.getMetavariableNode();
-
-      return labelMetavariableNode;
-    });
-
-    return labelMetavariableNodes;
-  }
-
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/topLevelAssertion.js

@@ -34,16 +34,6 @@ export default class TopLevelAssertion {
     return this.fileContext;
   }
 
-  getLabelMetavariableNodes() {
-    const labelMetavariableNodes = this.labels.map((label) => {
-      const labelMetavariableNode = label.getMetavariableNode();
-
-      return labelMetavariableNode;
-    });
-
-    return labelMetavariableNodes;
-  }
-
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/unify/qualifiedStatement.js

@@ -46,18 +46,17 @@ function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions,
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = rule.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
 
     const statementUnified = rule.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithRule = statementUnified;  ///
 
     if (qualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
@@ -72,18 +71,17 @@ function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = axiom.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
     const statementUnified = axiom.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithAxiom = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
@@ -98,18 +96,17 @@ function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = lemma.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
     const statementUnified = lemma.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithLemma = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
@@ -124,18 +121,17 @@ function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutio
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = theorem.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
     const statementUnified = theorem.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithTheorem = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
@@ -150,18 +146,17 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          labelMetavariableNodes = conjecture.getLabelMetavariableNodes(),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
-          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
+          metavariableString = localContext.nodeAsString(metavariableNode),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
     const statementUnified = conjecture.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithConjecture = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 

package/src/unify/termWithType.js

@@ -10,6 +10,5 @@ export default function unifyTermWithType(termNode, typeNode, localContext) {
 
   termUnifiedWithType = termVerifiedGivenType;  ///
 
-
   return termUnifiedWithType;
 }

package/src/verify/declaration.js

@@ -1,15 +1,15 @@
 "use strict";
 
 import shim from "../shim";
+import Reference from "../reference";
 import Declaration from "../declaration"
-import frameMetaType from "../metaType/frame";
 import referenceMetaType from "../metaType/reference";
 import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/declaration/statement"),
-      metavariableNodeQuery = nodeQuery("/declaration/metavariable");
+      metavariableNodeQuery = nodeQuery("/declaration/reference/metavariable"); ///
 
 const verifyDeclarationFunctions = [
   verifyDerivedDeclaration,
@@ -47,8 +47,9 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
     localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
     const metaType = referenceMetaType, ///
+          metavariables = [],
           metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
     if (metavariableVerifiedGivenMetaType) {
       const { verifyStatement } = shim,
@@ -58,7 +59,8 @@ function verifyDerivedDeclaration(declarationNode, declarations, stated, localCo
             statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
       if (statementVerified) {
-        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+        const reference = Reference.fromMetavariableNode(metavariableNode),
+          declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
 
         declarations.push(declaration);
 
@@ -82,26 +84,21 @@ function verifyStatedDeclaration(declarationNode, declarations, stated, localCon
 
     localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
 
-    const statementNode = statementNodeQuery(declarationNode),
-          metaType = (statementNode === null) ?
-                       frameMetaType :
-                         referenceMetaType,
+    const metaType = referenceMetaType, ///
+          metavariables = [],
           metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
+          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
     if (metavariableVerifiedGivenMetaType) {
-      let statementVerified = true; ///
-
-      if (statementNode !== null) {
         const { verifyStatement } = shim,
               stated = true,
-              assignments = null;
-
-        statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-      }
+              assignments = null,
+              statementNode = statementNodeQuery(declarationNode),
+              statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
       if (statementVerified) {
-        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+        const reference = Reference.fromMetavariableNode(metavariableNode),
+              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
 
         declarations.push(declaration);
 

package/src/verify/frame.js

@@ -1,13 +1,14 @@
 "use strict";
 
 import Frame from "../frame";
+import frameMetaType from "../metaType/frame";
 import verifyDeclaration from "../verify/declaration";
+import verifyMetavariableGivenMetaType from "./metavariableGivenMetaType";
 
 import { first } from "../utilities/array";
-import { nodeQuery, nodesQuery } from "../utilities/query";
+import { nodesQuery } from "../utilities/query";
 
-const declarationNodeQuery = nodeQuery("/frame/declaration!"),
-      declarationNodesQuery = nodesQuery("/frame/declaration"),
+const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
 const verifyFrameFunctions = [
@@ -45,35 +46,33 @@ function verifyDerivedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
 
-    const declarationNode = declarationNodeQuery(frameNode);
+    const declarations = [],
+          declarationNodes = declarationNodesQuery(frameNode),
+          declarationsVerified = declarationNodes.every((declarationNode) => {
+            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
 
-    if (declarationNode !== null) {
+            if (declarationVerified) {
+              return true;
+            }
+          });
 
-    }
-    const declarationNodesLength = declarationNodes.length;
-
-    if (declarationNodesLength === 1) {
+    if (declarationsVerified) {
       const metavariableNodes = metavariableNodesQuery(frameNode),
-            metavariableNodesLength = metavariableNodes.length;
+            metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+              const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-      if (metavariableNodesLength === 0) {
-        const firstDeclarationNode = first(declarationNodes),
-              declarationNode = firstDeclarationNode, ///
-              declarations = [],
-              declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+              if (metavariableVerified) {
+                return true;
+              }
+            });
 
-        if (declarationVerified) {
-          const frame = Frame.fromDeclarations(declarations);
+      if (metavariablesVerified) {
+        const frame = Frame.fromDeclarations(declarations);
 
-          frames.push(frame);
+        frames.push(frame);
 
-          derivedFrameVerified = true; ///
-        }
-      } else {
-        localContext.debug(`The '${frameString}' derived frame must no spread metavariables.`, frameNode);
+        derivedFrameVerified = true; ///
       }
-    } else {
-      localContext.debug(`The '${frameString}' derived frame must have one and only one declaration.`, frameNode);
     }
 
     if (derivedFrameVerified) {
@@ -92,29 +91,35 @@ function verifyStatedFrame(frameNode, frames, stated, localContext) {
 
     localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
 
-    const declarationNode = declarationNodeQuery(frameNode);
+    const declarationNodes = declarationNodesQuery(frameNode),
+          declarationNodesLength = declarationNodes.length;
 
-    if (declarationNode !== null) {
-      const declarations = [],
-            declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+    if (declarationNodesLength === 0) {
+      const metavariableNodes = metavariableNodesQuery(frameNode),
+            metavariableNodesLength = metavariableNodes.length;
+
+      if (metavariableNodesLength === 1) {
+        const firstMetavariableNode = first(metavariableNodes),
+              metavariableNode = firstMetavariableNode,
+              metaType = frameMetaType, ///
+              metavariables = [],
+              metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
 
-      if (declarationVerified) {
-        const firstDeclaration = first(declarations),
-              declaration = firstDeclaration, ///
-              statementNode = declaration.getStatementNode();
+        if (metavariableVerifiedGivenMetaType) {
+          const firstMetavariable = first(metavariables),
+                metavariable = firstMetavariable,
 
-        if (statementNode === null) {
-          const frame = Frame.fromDeclarations(declarations);
+          frame = Frame.fromMetavariable(metavariable);
 
           frames.push(frame);
 
           statedFrameVerified = true;
-        } else {
-          localContext.trace(`The '${frameString}' stated frame's declaration cannot contain a statement.`, frameNode);
         }
+      } else {
+        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`, frameNode);
       }
     } else {
-      localContext.trace(`The '${frameString}' stated frame has more than one declaration .`, frameNode);
+      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`, frameNode);
     }
 
     if (statedFrameVerified) {
@@ -124,3 +129,38 @@ function verifyStatedFrame(frameNode, frames, stated, localContext) {
 
   return statedFrameVerified;
 }
+
+function verifyMetavariable(metavariableNode, declarations, localContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metaType = frameMetaType, ///
+        metavariables = [],
+        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext);
+
+  if (metavariableVerifiedGivenMetaType) {
+    const firstMetavariable = first(metavariables),
+          metavariable = firstMetavariable, ///
+          metavariableName = metavariable.getName(),
+          judgement = localContext.findJudgementByMetavariableName(metavariableName);
+
+    if (judgement !== null) {
+      const declaration = judgement.getDeclaration();
+
+      declarations.push(declaration);
+
+      metavariableVerified = true;
+    } else {
+      localContext.trace(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
+    }
+  }
+
+  if (metavariableVerified) {
+    localContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verify/judgement.js

@@ -2,11 +2,12 @@
 
 import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
+import verifyDeclaration from "./declaration";
 import JudgementAssignment from "../assignment/judgement";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
-import verifyDeclaration from "./declaration";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const frameNodeQuery = nodeQuery("/judgement/frame"),
       declarationNodeQuery = nodeQuery("/judgement/declaration");
@@ -46,29 +47,31 @@ function verifyDerivedJudgement(judgementNode, assignments, stated, localContext
 
     localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
 
-    const frames = [],
-          frameNode = frameNodeQuery(judgementNode),
-          frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+    const declarations = [],
+          declarationNode = declarationNodeQuery(judgementNode),
+          declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+
+    if (declarationVerified) {
+      const firstDeclaration = first(declarations),
+            declaration = firstDeclaration, ///
+            metavariableNode = declaration.getMetavariableNode(),
+            metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
+            metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
+            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+
+      if (metaLemmaMetatheorem !== null) {
+        const frames = [],
+              frameNode = frameNodeQuery(judgementNode),
+              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
+
+        if (frameVerified) {
+          const firstFrame = first(frames),
+                frame = firstFrame, ///
+                metaLemmaMetatheoremUnified = frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
 
-    if (frameVerified) {
-      // const firstFrame = first(frames),
-      //       frame = firstFrame, ///
-      //       declaration = frame.getDeclaration(),
-      //       metavariableNode = declaration.getMetavariableNode(),
-      //       metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-      //       metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-      //       metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-      //
-      // if (metaLemmaMetatheorem !== null) {
-      //   const metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem),
-      //         metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
-      //
-      //   derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithJudgement && metaLemmaMetatheoremUnifiedWithDeclaration);
-      // }
-    } else {
-      // const metavariableString = localContext.nodeAsString(metavariableNode);
-      //
-      // localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode)
+          derivedJudgementVerified = metaLemmaMetatheoremUnified; ///
+        }
+      }
     }
 
     if (derivedJudgementVerified) {
@@ -92,24 +95,33 @@ function verifyStatedJudgement(judgementNode, assignments, stated, localContext)
           frameVerified = verifyFrame(frameNode, frames, stated, localContext);
 
     if (frameVerified) {
-      const declarations = [],
-            declarationNode = declarationNodeQuery(judgementNode),
-            declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-      if (declarationVerified) {
-        if (assignments !== null) {
-          const firstDeclaration = first(declarations),
-                declaration = firstDeclaration, ///
-                firstFrame = first(frames),
-                frame = firstFrame, ///
-                judgement = Judgement.fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration),
-                judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-                assignment = judgementAssignment;
-
-          assignments.push(assignment);
+      const firstFrame = first(frames),
+            frame = firstFrame, ///
+            metavariable = frame.getMetavariable(),
+            metavariableNode = metavariable.getNode(),
+            metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            judgementPresent = localContext.isJudgementPresentByMetavariableName(metavariableName);
+
+      if (!judgementPresent) {
+        const declarations = [],
+              declarationNode = declarationNodeQuery(judgementNode),
+              declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
+
+        if (declarationVerified) {
+          if (assignments !== null) {
+            const firstDeclaration = first(declarations),
+                  declaration = firstDeclaration, ///
+                  judgement = Judgement.fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration),
+                  judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+                  assignment = judgementAssignment;
+
+            assignments.push(assignment);
+          }
+
+          statedJudgementVerified = true;
         }
-
-        statedJudgementVerified = true;
+      } else {
+        localContext.trace(`There is already a judgement for the '${metavariableName}' metavariable.`, judgementNode);
       }
     }
 

package/src/verify/metavariableGivenMetaType.js

@@ -4,7 +4,7 @@ import metavariableUnifier from "../unifier/metavariable";
 
 import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
-export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext) {
+export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, metavariables, localContext) {
   let metavariableVerifiedGivenMetaType = false;
 
   const metaTypeName = metaType.getName(),
@@ -27,7 +27,11 @@ export default function verifyMetavariableGivenMetaType(metavariableNode, metaTy
 
       const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-      metavariableVerifiedGivenMetaType = unified; ///
+      if (unified) {
+        metavariables.push(metavariable);
+
+        metavariableVerifiedGivenMetaType = true;
+      }
     } else {
       const metavariableMetaTypeName = metavariableMetaType.getName();
 

package/src/verify/statement.js

@@ -96,7 +96,7 @@ function verifyStatementAsMetavariable(statementNode, assignments, stated, local
 
     const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
 
-    statementVerifiedAsMetavariable = metavariableUnified;
+    statementVerifiedAsMetavariable = metavariableUnified;  ///
 
     if (statementVerifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);