occam-verify-cli 1.0.718 → 1.0.721

package/src/element/proofAssertion.js

@@ -38,9 +38,7 @@ export default class ProofAssertion extends Element {
 
     const leftStatement = statement,  ///
           rightStatement = this.statement,  ///
-          leftStatementNode = leftStatement.getNode(),
-          rightStatementNode = rightStatement.getNode(),
-          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
+          statementsEquate = equateStatements(leftStatement, rightStatement, context);
 
     if (statementsEquate) {
       comparesToStatement = true;

package/src/element/reference.js

@@ -125,20 +125,41 @@ export default define(class Reference extends Element {
     } else {
       let validates = false;
 
-      if (!validates) {
-        const metavariableValidates = this.validateMetavariable(context);
-
-        if (metavariableValidates) {
-          validates = true;
-        }
-      }
-
-      if (!validates) {
-        const reference = this, ///
-              labelPresent = context.isLabelPresentByReference(reference);
-
-        if (labelPresent) {
-          validates = true;
+      const metavariableValidates = this.validateMetavariable(context);
+
+      if (metavariableValidates) {
+        const referenceMetaTypeName = REFERENCE_META_TYPE_NAME,
+              referenceMetaType = context.findMetaTypeByMetaTypeName(referenceMetaTypeName),
+              metaType = this.metavariable.getMetaType();
+
+        if (metaType === null) {
+          const reference = this, ///
+                labelPresent = context.isLabelPresentByReference(reference);
+
+          if (labelPresent) {
+            validates = true;
+          } else {
+            context.debug(`There is no label for the '${referenceString}' reference.`);
+          }
+        } else {
+          const metavariableMetaTypeEqualToReferenceMetaType = this.metavariable.isMetaTypeEqualTo(referenceMetaType);
+
+          if (metavariableMetaTypeEqualToReferenceMetaType) {
+            const reference = this, ///
+                  metavariablePresent = context.isMetavariablePresentByReference(reference);
+
+            if (metavariablePresent) {
+              validates = true;
+            } else {
+              context.debug(`There is no metavariable for the '${referenceString}' reference.`);
+            }
+          } else {
+            const metaTypeString = metaType.getString(),
+                  metavariableString = this.metavariable.getString(),
+                  reerenceMetaTypeString = referenceMetaType.getString();
+
+            context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${reerenceMetaTypeString}' meta-type.`);
+          }
         }
       }
 
@@ -162,44 +183,19 @@ export default define(class Reference extends Element {
 
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
-    const metaTypeName = REFERENCE_META_TYPE_NAME,
-          referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
-          metaType = referenceMetaType, ///
-          metavariable = context.findMetavariable(this.metavariable, context);
+    const metavariable = this.metavariable.validate(context);
 
     if (metavariable !== null) {
-      const metavariableValidatesGivenMetaType = metavariable.validateGivenMetaType(metaType, context);
-
-      if (metavariableValidatesGivenMetaType) {
-        metavariableValidates = true;
-      }
-    } else {
-      context.debug(`The '${metavariableString}' metavariable is not present.`);
-    }
-
-    return metavariableValidates;
-  }
-
-  validateAsMetavariable(context) {
-    let validatesAsMetavariable = false;
-
-    const referenceString = this.getString(); ///
+      this.metavariable = metavariable;
 
-    context.trace(`Validating the '${referenceString}' reference as a metavaraible...`);
-
-    const metavariable = this.getMetavariable(),
-          metavariableName = metavariable.getName(),
-          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (metavariablePresent) {
-      validatesAsMetavariable = true;
+      metavariableValidates = true;
     }
 
-    if (validatesAsMetavariable) {
-      context.debug(`...validated the '${referenceString}' reference as a metavaraible.`);
+    if (metavariableValidates) {
+      context.debug(`...validated the '${referenceString}' reference's '${metavariableString}' metavariable.'`);
     }
 
-    return validatesAsMetavariable;
+    return metavariableValidates;
   }
 
   unifyLabel(label, context) {
@@ -301,8 +297,11 @@ export default define(class Reference extends Element {
       const { string } = json,
             referenceNode = instantiateReference(string, context),
             node = referenceNode,  ///
-            metavariable = metavariableFromReferenceNode(referenceNode, context),
-            reference = new Reference(context, string, node, metavariable);
+            metavariable = metavariableFromReferenceNode(referenceNode, context);
+
+      context = null;
+
+      const reference = new Reference(context, string, node, metavariable);
 
       return reference;
     }, context);

package/src/element/statement.js

@@ -8,7 +8,6 @@ import { literally } from "../utilities/context";
 import { unifyStatement } from "../process/unify";
 import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
-import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const { match, backwardsSome } = arrayUtilities;
 
@@ -209,31 +208,6 @@ export default define(class Statement extends Element {
     return statement;
   }
 
-  validateGivenMetaType(metaType, stated, context) {
-    let validatesGivenMetaType = false;
-
-    const metaTypeString = metaType.getString(),
-          statementString = this.getString();  ///
-
-    context.trace(`Validating the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
-
-    const metaTypeName = metaType.getName();
-
-    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const statement = this.validate(stated, context)
-
-      if (statement !== null) {
-        validatesGivenMetaType = true;
-      }
-    }
-
-    if (validatesGivenMetaType) {
-      context.debug(`...validated the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
-    }
-
-    return validatesGivenMetaType;
-  }
-
   unifySubproof(subproof, generalContext, specificContext) {
     let subproofUnifies = false;
 

package/src/element/variable.js

@@ -95,31 +95,6 @@ export default define(class Variable extends Element {
     return validates;
   }
 
-  validateType(context) {
-    let typeValidates = false;
-
-    const typeString = this.type.getString();
-
-    context.trace(`Validating the '${typeString}' type...`);
-
-    const prefixedTypeName = this.type.getPrefixedName(),
-          type = context.findTypeByPrefixedTypeName(prefixedTypeName);
-
-    if (type === null) {
-      context.debug(`The '${typeString}' type is not present.`);
-    } else {
-      this.type = type; ///
-
-      typeValidates = true;
-    }
-
-    if (typeValidates) {
-      context.debug(`...validated the '${typeString}' type.`);
-    }
-
-    return typeValidates;
-  }
-
   unifyTerm(term, generalContext, specificContext) {
     let termUnifies = false;
 

package/src/process/equate.js

@@ -63,10 +63,12 @@ class EquationalPass extends EquivalencePass {
 
 const equationalPass = new EquationalPass();
 
-export function equateTerms(leftTermNode, rightTermNode, context) {
+export function equateTerms(leftTerm, rightTerm, context) {
   let termsEquate;
 
-  const leftNode = leftTermNode, ///
+  const leftTermNode = leftTerm.getNode(),
+        rightTermNode = rightTerm.getNode(),
+        leftNode = leftTermNode, ///
         rightNode = rightTermNode, ///
         success = equationalPass.run(leftNode, rightNode, context);
 
@@ -75,10 +77,12 @@ export function equateTerms(leftTermNode, rightTermNode, context) {
   return termsEquate;
 }
 
-export function equateStatements(leftStatementNode, rightStatementNode, context) {
+export function equateStatements(leftStatement, rightStatement, context) {
   let statementsEquate;
 
-  const leftNode = leftStatementNode, ///
+  const leftStatementNode = leftStatement.getNode(),
+        rightStatementNode = rightStatement.getNode(),
+        leftNode = leftStatementNode, ///
         rightNode = rightStatementNode, ///
         success = equationalPass.run(leftNode, rightNode, context);
 

package/src/process/unify.js

@@ -4,6 +4,7 @@ import { queryUtilities, ZipPass as ZipPassBase } from "occam-languages";
 
 import ZipPass from "../pass/zip";
 
+import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
 const { nodeQuery } = queryUtilities;
@@ -155,22 +156,22 @@ class CombinatorPass extends ZipPass {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
-              statementNode = specificStatementNode; ///
+              metaTypeName = metaTypeNode.getMetaTypeName(),
+              metaTypeNameStatementMetaTypeName = (metaTypeName === STATEMENT_META_TYPE_NAME);
 
-        let context;
-
-        context = generalContext; ///
+        if (metaTypeNameStatementMetaTypeName) {
+          const context = specificContext,  ///
+                statementNode = specificStatementNode;  ///
 
-        const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+          let statement;
 
-        context = specificContext;  ///
+          statement = statementFromStatementNode(statementNode, context);
 
-        const statement = statementFromStatementNode(statementNode, context),
-              statementValidatesGivenType = statement.validateGivenMetaType(metaType, stated, context);
+          statement = statement.validate(stated, context);  ///
 
-        if (statementValidatesGivenType) {
-          success = true;
+          if (statement !== null) {
+            success = true;
+          }
         }
 
         return success;
@@ -183,22 +184,22 @@ class CombinatorPass extends ZipPass {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
-              frameNode = specificFrameNode; ///
+              metaTypeName = metaTypeNode.getMetaTypeName(),
+              metaTypeNameFrameMetaTypeName = (metaTypeName === FRAME_META_TYPE_NAME);
 
-        let context;
-
-        context = generalContext; ///
+        if (metaTypeNameFrameMetaTypeName) {
+          const context = specificContext,  ///
+                frameNode = specificFrameNode;  ///
 
-        const metaTypeName = metaTypeNode.getMetaTypeName(),
-              metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+          let frame;
 
-        context = specificContext;  ///
+          frame = frameFromFrameNode(frameNode, context);
 
-        const frame = frameFromFrameNode(frameNode, context),
-              frameValidatesGivenMetaType = frame.validateGivenMetaType(metaType, stated, context);
+          frame = frame.validate(stated, context);  ///
 
-        if (frameValidatesGivenMetaType) {
-          success = true;
+          if (frame !== null) {
+            success = true;
+          }
         }
 
         return success;

package/src/process/validate.js

@@ -1,7 +1,7 @@
 "use strict";
 
+import { SimplePass } from "occam-languages";
 import { queryUtilities } from "occam-languages";
-import { SimplePass, ForwardPass } from "occam-languages";
 
 import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 
@@ -11,144 +11,6 @@ const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type"),
       statementNodeQuery = nodeQuery("/statement");
 
-class TermPass extends ForwardPass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context, validateForwards) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, validateForwards);  ///
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context, validateForwards) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          const validatesForwards = validateForwards();
-
-          if (validatesForwards) {
-            success = true;
-          }
-        } else {
-          const typeString = nominalTypeName; ///
-
-          context.debug(`The '${typeString}' type is not present.`);
-
-          success = false;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
-class StatementPass extends SimplePass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: statementNodeQuery,
-      run: (statementNode, context) => {
-        let success = false;
-
-        let statement;
-
-        const stated = true;
-
-        statement = statementFromStatementNode(statementNode, context);
-
-        statement = statement.validate(stated, context);  ///
-
-        if (statement !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, () => { ///
-          const validatesForwards = true;
-
-          return validatesForwards;
-        });
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
 class ConbinatorPass extends SimplePass {
   run(statementNode, context) {
     let success = false;
@@ -281,37 +143,9 @@ class ConstructorPass extends SimplePass {
   ];
 }
 
-const termPass = new TermPass(),
-      statementPass = new StatementPass(),
-      combinatorPass = new ConbinatorPass(),
+const combinatorPass = new ConbinatorPass(),
       constructorPass = new ConstructorPass();
 
-export function validateTerm(termNode, context, validateForwards) {
-  let termValidates = false;
-
-  const node = termNode, ///
-        sucess = termPass.run(node, context, validateForwards);
-
-  if (sucess) {
-    termValidates = true;
-  }
-
-  return termValidates;
-}
-
-export function validateStatement(statementNode, context) {
-  let statementValidates = false;
-
-  const node = statementNode, ///
-        sucess = statementPass.run(node, context);
-
-  if (sucess) {
-    statementValidates = true;
-  }
-
-  return statementValidates;
-}
-
 export function validateTermAsConstructor(term, context) {
   let termValidatesAsConstructor = false;
 

package/src/utilities/element.js

@@ -123,12 +123,12 @@ export function frameFromFrameNode(frameNode, context) {
   const { Frame } = elements,
         node = frameNode, ///
         string = context.nodeAsString(node),
-        reference = referenceFromFrameNode(frameNode, context),
-        assumptions = assumptionsFromFrameNode(frameNode, context);
+        assumptions = assumptionsFromFrameNode(frameNode, context),
+        metavariable = metavariableFromFrameNode(frameNode, context);
 
   context = null;
 
-  const frame = new Frame(context, string, node, reference, assumptions);
+  const frame = new Frame(context, string, node, assumptions, metavariable);
 
   return frame;
 }
@@ -320,8 +320,11 @@ export function referenceFromReferenceNode(referenceNode, context) {
   const { Reference } = elements,
         node = referenceNode, ///
         string = context.nodeAsString(node),
-        metavariable = metavariableFromReferenceNode(referenceNode, context),
-        reference = new Reference(context, string, node, metavariable);
+        metavariable = metavariableFromReferenceNode(referenceNode, context);
+
+  context = null;
+
+  const reference = new Reference(context, string, node, metavariable);
 
   return reference;
 }
@@ -549,11 +552,11 @@ export function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = elements,
         node = metavariableNode,  ///
         string = context.nodeAsString(node),
-        metavariableName = metavariableNode.getMetavariableName(),
-        name = metavariableName,  ///
-        type = null,
+        name = nameFromMetavariableNode(metavariableNode, context),
+        term = termFromMetavariableNode(metavariableNode, context),
+        type = typeFromMetavariableNode(metavariableNode, context),
         metaType = null,
-        metavariable = new Metavariable(context, string, node, name, type, metaType);
+        metavariable = new Metavariable(context, string, node, name, term, type, metaType);
 
   return metavariable;
 }
@@ -966,18 +969,6 @@ export function conclusionFromRuleNode(ruleNode, context) {
   return conclusion;
 }
 
-export function referenceFromFrameNode(frameNode, context) {
-  let reference = null;
-
-  const metavariableNode = frameNode.getMetavariableNode();
-
-  if (metavariableNode !== null) {
-    reference = referencesFromMetavariableNode(metavariableNode, context);
-  }
-
-  return reference;
-}
-
 export function theoremFromSectionNode(sectionNode, context) {
   let theorem = null;
 
@@ -1070,6 +1061,30 @@ export function nameFromMetavariableNode(metavariableNode, context) {
   return name;
 }
 
+export function termFromMetavariableNode(metavariableNode, context) {
+  let term = null;
+
+  const termNode = metavariableNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term;
+}
+
+export function typeFromMetavariableNode(metavariableNode, context) {
+  let type = null;
+
+  const typemNode = metavariableNode.getTypeNode();
+
+  if (typemNode !== null) {
+    type = typeFromTypeNode(typemNode, context);
+  }
+
+  return type;
+}
+
 export function metavariableFromFrameNode(frameNode, context) {
   let metavariable = null;