occam-verify-cli 0.0.538 → 0.0.539

package/src/verify/declaration/topLevel.js

@@ -9,6 +9,7 @@ import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
 import verifyConstructorDeclaration from "../../verify/declaration/constructor";
+import verifyMetavariableDeclaration from "../../verify/declaration/metavariable";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -20,7 +21,8 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
-      constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
+      constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!"),
+      metavariableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/metavariableDeclaration!");
 
 export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
@@ -34,7 +36,8 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
-        constructorDeclarationNode = constructorDeclarationNodeQuery(node);
+        constructorDeclarationNode = constructorDeclarationNodeQuery(node),
+        metavariableDeclarationNode = metavariableDeclarationNodeQuery(node);
 
   if (false) {
     ///
@@ -74,6 +77,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
+  } else if (metavariableDeclarationNode !== null) {
+    const metavariableDeclarationVerified = verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext);
+
+    topLevelDeclarationVerified = metavariableDeclarationVerified;  ///
   }
 
   return topLevelDeclarationVerified;

package/src/verify/lemma.js

@@ -53,7 +53,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
               proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+          const lemma = Lemma.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metastatement/qualified.js

@@ -11,7 +11,8 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode),
+          metastatementMetaproofContext = metaproofContext; ///
 
     metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
@@ -20,7 +21,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
           rule = metaproofContext.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementMetaproofContext);
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }

package/src/verify/metavariable.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import Metavariable from "../metavariable";
+
+import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } from "../utilities/query";
+
+export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
+  let metavariableVerified = false;
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariableString = fileContext.nodeAsString(metavariableNode),
+        metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+  if (metavariablePresent) {
+    fileContext.error(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+  } else {
+    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+          metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
+          name = metavariableName,  ///
+          metavariable = Metavariable.fromNameAndMetaType(name, metaType);
+
+    fileContext.addMetavariable(metavariable);
+
+    metavariableVerified = true;
+  }
+
+  if (metavariableVerified) {
+    fileContext.info(`Verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verify/rule.js

@@ -55,7 +55,7 @@ export default function verifyRule(ruleNode, fileContext) {
         }
 
         if (ruleProofVerified) {
-          const rule = Rule.fromLabelsPremisesAndConclusion(labels, premises, conclusion);
+          const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
 
           fileContext.addRule(rule);
 

package/src/verify/statement/qualified.js

@@ -11,7 +11,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = proofContext.nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode),
+          statementProofContext = proofContext; ///
 
     proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
@@ -22,7 +23,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const rule = proofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+        const ruleMatchesStatement = rule.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = ruleMatchesStatement;  ///
       }
@@ -32,7 +33,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const axiom = proofContext.findAxiomByReferenceName(referenceName);
 
       if (axiom !== null) {
-        const axiomMatchesStatement = axiom.matchStatement(statementNode, proofContext);
+        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = axiomMatchesStatement; ///
       }
@@ -42,7 +43,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const lemma = proofContext.findLemmaByReferenceName(referenceName);
 
       if (lemma !== null) {
-        const lemmaMatchesStatement = lemma.matchStatement(statementNode, proofContext);
+        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = lemmaMatchesStatement; ///
       }
@@ -52,7 +53,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const theorem = proofContext.findTheoremByReferenceName(referenceName);
 
       if (theorem !== null) {
-        const theoremMatchesStatement = theorem.matchStatement(statementNode, proofContext);
+        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = theoremMatchesStatement; ///
       }
@@ -62,7 +63,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
       const conjecture = proofContext.findConjectureByReferenceName(referenceName);
 
       if (conjecture !== null) {
-        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, proofContext);
+        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementProofContext);
 
         qualifiedStatementVerified = conjectureMatchesStatement; ///
       }

package/src/verify/statement.js

@@ -254,18 +254,18 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
                 rightVariableTypeSuperTypeOfLeftVariableType = rightVariableType.isSuperTypeOf(leftVariableType);
 
           if (leftVariableTypeSuperTypeOfRightVariableType) {
-            const type = rightVariableType,  ///
-                  name = leftVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = leftVariableName, ///
+                  type = rightVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
           }
 
           if (rightVariableTypeSuperTypeOfLeftVariableType) {
-            const type = leftVariableType,  ///
-                  name = rightVariableName, ///
-                  variable = Variable.fromTypeAndName(type, name),
+            const name = rightVariableName, ///
+                  type = leftVariableType,  ///
+                  variable = Variable.fromNameAndType(name, type),
                   assignment = Assignment.fromVariable(variable);
 
             assignments.push(assignment);
@@ -293,9 +293,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
         } else {
-          const type = rightTermType, ///
-                name = leftVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = leftVariableName,  ///
+                type = rightTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);
@@ -322,9 +322,9 @@ function verifyStatementAsEquality(statementNode, assignments, derived, context)
 
           context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
         } else {
-          const type = leftTermType, ///
-                name = rightVariableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = rightVariableName,  ///
+                type = leftTermType, ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);

package/src/verify/theorem.js

@@ -9,6 +9,7 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import proof from "../context/proof";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
       labelNodesQuery = nodesQuery("/theorem/label"),
@@ -50,7 +51,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
               proofVerified = verifyProof(proofNode, consequence, proofContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+          const theorem = Theorem.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
           fileContext.addTheorem(theorem);
 

package/src/verify/variable.js

@@ -20,10 +20,10 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
     const typeName = typeNameFromTypeNode(typeNode);
     
     if (typeName === null) {
-      const type = objectType,
-            name = variableName;  ///
+      const name = variableName,  ///
+            type = objectType;
 
-      variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
     } else {
       const type = fileContext.findTypeByTypeName(typeName);
 
@@ -32,7 +32,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
       } else {
         const name = variableName;  ///
 
-        variable = Variable.fromTypeAndName(type, name);
+        variable = Variable.fromNameAndType(name, type);
       }
     }