occam-verify-cli 1.0.715 → 1.0.721

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

@@ -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;
 }
@@ -532,15 +535,28 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
   return metatheorem;
 }
 
+export function referencesFromMetavariableNode(metavariableNode, context) {
+  const { Reference } = elements,
+        node = metavariableNode, ///
+        string = context.nodeAsString(node),
+        metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+  context = null;
+
+  const reference = new Reference(context, string, node, metavariable);
+
+  return reference
+}
+
 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;
 }
@@ -1045,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;