occam-verify-cli 1.0.732 → 1.0.734

package/src/element/substitution/metaLevel.js

@@ -0,0 +1,201 @@
+"use strict";
+
+import Substitution from "../substitution";
+
+import { define } from "../../elements";
+import { literally } from "../../utilities/context";
+import { ephemeralContextFromJSON } from "../../utilities/json";
+import { instantiateMetaLevelSubstitution } from "../../process/instantiate";
+import { metaLevelSubstitutionStringFromStatementAndReference } from "../../utilities/string";
+import { targetReferenceFromMetaLevelSubstitutionNode, replacementStatementFromMetaLevelSubstitutionNode, metaLevelSubstitutionFromMetaLevelSubstitutionNode } from "../../utilities/element";
+
+export default define(class MetaLevelSubstitution extends Substitution {
+  constructor(context, string, node, targetReference, replacementStatement) {
+    super(context, string, node);
+
+    this.targetReference = targetReference;
+    this.replacementStatement = replacementStatement;
+  }
+
+  getTargetReference() {
+    return this.targetReference;
+  }
+
+  getReplacementStatement() {
+    return this.replacementStatement;
+  }
+
+  getMetaLevelSubstitutionNode() {
+    const node = this.getNode(),
+          metaLevelSubstitutionNode = node; ///
+
+    return metaLevelSubstitutionNode;
+  }
+
+  getTargetNode() {
+    const targetReferenceNode = this.targetReference.getNode(),
+          tergetNode = targetReferenceNode; ///
+
+    return tergetNode;
+  }
+
+  getReplacementNode() {
+    const replacementStatementNode = this.replacementStatement.getNode(),
+          replacementNode = replacementStatementNode; ///
+
+    return replacementNode;
+  }
+
+  validate(generalContext, specificContext) {
+    let metaLevelSubstitution = null;
+
+    const context = this.getContext();
+
+    specificContext = context;  ///
+
+    const metaLevelSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution...`);
+
+    const validSubstitution = this.findValidSubstiution(context);
+
+    if (validSubstitution) {
+      metaLevelSubstitution = validSubstitution;  ///
+
+      context.debug(`...the '${metaLevelSubstitutionString}' meta-level substitution is already valid.`);
+    } else {
+      let validates = false;
+
+      const targetReferenceValidates = this.validateTargetReference(generalContext, specificContext);
+
+      if (targetReferenceValidates) {
+        const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
+
+        if (replacementStatementValidates) {
+          validates = true;
+        }
+      }
+
+      if (validates) {
+        const substitution = this;  ///
+
+        metaLevelSubstitution = substitution; ///
+
+        context.addSubstitution(substitution);
+
+        context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level substitution.`);
+      }
+    }
+
+    return metaLevelSubstitution;
+  }
+
+  validateTargetReference(generalContext, specificContext) {
+    let targetReferenceValidates = false;
+
+    const context = generalContext, ///
+          targetReferenceString = this.targetReference.getString(),
+          metaLevelSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level subtitution's '${targetReferenceString}' target reference...`);
+
+    const targetReference = this.targetReference.validate(context);
+
+    if (targetReference !== null) {
+      targetReferenceValidates = true;
+    }
+
+    if (targetReferenceValidates) {
+      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level subtitution's '${targetReferenceString}' target reference...`);
+    }
+
+    return targetReferenceValidates;
+  }
+
+  validateReplacementStatement(generalContext, specificContext) {
+    let replacementStatementValidates;
+
+    const context = specificContext,  ///
+          replacementStatementString = this.replacementStatement.getString(),
+          metaLevelSubstitutionString = this.getString();  ///
+
+    context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level subtitution's '${replacementStatementString}' replacement statement...`);
+
+    const stated = true,
+      replacementStatement = this.replacementStatement.validate(stated, context);
+
+    if (replacementStatement !== null) {
+      replacementStatementValidates = true;
+    }
+
+    if (replacementStatementValidates) {
+      context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level subtitution's '${replacementStatementString}' replacement statement.`);
+    }
+
+    return replacementStatementValidates;
+  }
+
+  toJSON() {
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
+    const string = this.getString(),
+          json = {
+            context,
+            string
+          };
+
+    return json;
+  }
+
+  static name = "MetaLevelSubstitution";
+
+  static fromJSON(json, context) {
+    const metaLevelSubstitution = literally((context) => {
+      const { string } = json,
+            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
+            targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+            replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+            node = metaLevelSubstitutionNode, ///
+            ephemeralContext = ephemeralContextFromJSON(json, context);
+
+      context = ephemeralContext; ///
+
+      const metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+
+      return metaLevelSubstitution;
+    }, context);
+
+    return metaLevelSubstitution;
+  }
+
+  static fromStatementAndReference(statement, reference, context) {
+    return literally((context) => {
+      const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
+            string = metaLevelSubstitutionString,  ///
+            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
+            metaLevelSubstitution = metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
+
+      return metaLevelSubstitution;
+    }, context);
+  }
+});
+
+function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
+  const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
+        targetReference = context.findReferenceByReferenceNode(targetReferenceNode);
+
+  return targetReference;
+}
+
+function replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
+  const replacementStatementNode = metaLevelSubstitutionNode.getReplacementStatementNode(),
+        replacementStatement = context.findStatementByStatementNode(replacementStatementNode);
+
+  return replacementStatement;
+}

package/src/element/substitution/reference.js

@@ -123,16 +123,10 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference...`);
 
-    const targetReferenceSingular = this.targetReference.isSingular();
+    const targetReference = this.targetReference.validate(context);
 
-    if (targetReferenceSingular) {
-      const targetReference = this.targetReference.validate(context);
-
-      if (targetReference !== null) {
-        targetReferenceValidates = true;
-      }
-    } else {
-      context.debug(`The '${referenceSubstitutionString}' reference subtitution's '${targetReferenceString}' target reference is not singular.`);
+    if (targetReference !== null) {
+      targetReferenceValidates = true;
     }
 
     if (targetReferenceValidates) {

package/src/node/substitution/metaLevel.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import SubstitutionNode from "../../node/substitution";
+
+import { STATEMENT_RULE_NAME, REFERENCE_RULE_NAME } from "../../ruleNames";
+
+export default class MetaLevelSubstitutionNode extends SubstitutionNode {
+  getTargetReferenceNode() {
+    const referenceNode = this.getReferenceNode(),
+          targetReferenceNode = referenceNode; ///
+
+    return targetReferenceNode;
+  }
+
+  getReplacementStatementNode() {
+    const statementNode = this.getStatementNode(),
+          replacementStatementNode = statementNode; ///
+
+    return replacementStatementNode;
+  }
+
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getFirstNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLevelSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNodeMap.js

@@ -75,10 +75,11 @@ import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
-import ReferenceSubstitutionNode from "./node/substitution/reference";
-import StatementSubstitutionNode from "./node/substitution/statement";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
+import ReferenceSubstitutionNode from "./node/substitution/reference";
+import StatementSubstitutionNode from "./node/substitution/statement";
+import MetaLevelSubstitutionNode from "./node/substitution/metaLevel";
 import TypePrefixDeclarationNode from "./node/declaration/typePrefix";
 import ComplexTypeDeclarationNode from "./node/declaration/complexType";
 import DonstructorDeclarationNode from "./node/declaration/constructor";
@@ -160,9 +161,10 @@ import {
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
   VARIABLE_DECLARATION_RULE_NAME,
+  COMBINATOR_DECLARATION_RULE_NAME,
   REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
-  COMBINATOR_DECLARATION_RULE_NAME,
+  META_LEVEL_SUBSTITUTION_RULE_NAME,
   SIMPLE_TYPE_DECLARATION_RULE_NAME,
   CONSTRUCTOR_DECLARATION_RULE_NAME,
   TYPE_PREFIX_DECLARATION_RULE_NAME,
@@ -245,9 +247,10 @@ const NonTerminalNodeMap = {
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
+  [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
   [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
-  [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
+  [META_LEVEL_SUBSTITUTION_RULE_NAME]: MetaLevelSubstitutionNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
   [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,
   [CONSTRUCTOR_DECLARATION_RULE_NAME]: DonstructorDeclarationNode,

package/src/preamble.js

@@ -57,6 +57,7 @@ import SimpleTypeDeclaration from "./element/declaration/simpleType";
 import StatementSubstitution from "./element/substitution/statement";
 import ReferenceSubstitution from "./element/substitution/reference";
 import CombinatorDeclaration from "./element/declaration/combinator";
+import MetaLevelSubstitution from "./element/substitution/metaLevel";
 import TypePrefixDeclaration from "./element/declaration/typePrefix";
 import ConstructorDeclaration from "./element/declaration/constructor";
 import ComplexTypeDeclaration from "./element/declaration/complexType";

package/src/process/instantiate.js

@@ -34,7 +34,8 @@ import { TERM_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
-         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+         REFERENCE_SUBSTITUTION_RULE_NAME,
+         META_LEVEL_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       typePlaceholderRule = ruleFromRuleName(TYPE_RULE_NAME),
@@ -69,7 +70,8 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
-      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME),
+      metaLevelSubstitutionPlaceholderRule = ruleFromRuleName(META_LEVEL_SUBSTITUTION_RULE_NAME);
 
 export function instantiatePremise(string, context) {
   string = `${string}
@@ -159,6 +161,8 @@ export function instantiateStatementSubstitution(string, context) { return insta
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
 
+export function instantiateMetaLevelSubstitution(string, context) { return instantiate(metaLevelSubstitutionPlaceholderRule, string, context); }
+
 function instantiate(placeholderRule, string, context) {
   let node;
 

package/src/ruleNames.js

@@ -75,9 +75,10 @@ export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
 export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
-export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
+export const META_LEVEL_SUBSTITUTION_RULE_NAME = "metaLevelSubstitution";
 export const TYPE_PREFIX_DECLARATION_RULE_NAME = "typePrefixDeclaration";
 export const SIMPLE_TYPE_DECLARATION_RULE_NAME = "simpleTypeDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/utilities/context.js

@@ -38,14 +38,14 @@ export function synthetically(innerFunction, contexts, context) {
   return innerFunction(context);
 }
 
-export async function asyncScope(innerFunction, substitutions, context) {
+export async function asyncScope(innerFunction, metaLevelSubstitutions, context) {
   if (context === undefined) {
-    context = substitutions;  ///
+    context = metaLevelSubstitutions;  ///
 
-    substitutions = null;
+    metaLevelSubstitutions = null;
   }
 
-  const scopedContext = ScopedContext.fromSubstitutions(substitutions, context);
+  const scopedContext = ScopedContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
 
   context = scopedContext;  ///
 

package/src/utilities/element.js

@@ -13,6 +13,7 @@ import { equivalenceStringFromTerms,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
          topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+import EphemeralContext from "../context/ephemeral";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -795,6 +796,21 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
   return statementSubstitution;
 }
 
+export function metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
+  const { MetaLevelSubstitution } = elements,
+        node = metaLevelSubstitutionNode,  ///
+        string = context.nodeAsString(node),
+        targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+        replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+        ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext; ///
+
+  const metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+
+  return metaLevelSubstitution;
+}
+
 export function constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   const { ConstructorDeclaration } = elements,
         node = constructorDeclarationNode, ///
@@ -1859,7 +1875,14 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
 
 export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
-        targetRefernece = metavariableFromMetavariableNode(targetReferenceNode, context);
+        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
+
+  return targetRefernece;
+}
+
+export function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
+  const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
+        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
 
   return targetRefernece;
 }
@@ -1909,6 +1932,13 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
+export function replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
+  const replacementStatementNode = metaLevelSubstitutionNode.getReplacementStatementNode(),
+        replacementStatement = statementFromStatementNode(replacementStatementNode, context);
+
+  return replacementStatement;
+}
+
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);

package/src/utilities/string.js

@@ -184,20 +184,12 @@ export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavaria
   return string;
 }
 
-export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
-  let typeString;
-
-  typeString = (typePrefixName !== null) ?
-                 `${typePrefixName}${typeName}`:
-                   typeName;
-
-  const superTypesString = superTypesStringFromSuperTypes(superTypes);
-
-  if (superTypesString !== null) {
-    typeString = `${typeString}:${superTypesString}`;
-  }
+export function metaLevelSubstitutionStringFromStatementAndReference(statement, reference) {
+  const statementString = statement.getString(),
+        referenceString = reference.getString(),
+        metaLevelSubstitutionString = `[${statementString} for ${referenceString}]`;
 
-  return typeString;
+  return metaLevelSubstitutionString;
 }
 
 export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {

package/src/utilities/unification.js

@@ -62,17 +62,22 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
       const metaLevelSubstitutions = context.hasMetaLevelSubstitutions();
 
       if (metaLevelSubstitutions) {
-        const { StatementSubstitution } = elements,
-              metavariable = reference.getMetavariable(),
-              statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
-              substitution = statementSubstitution, ///
-              metaLevel = true;
+        let metaLevelSubstitution;
 
-        context = context.getContext(); ///
+        const { MetaLevelSubstitution } = elements;
 
-        context.addSubstitution(substitution, metaLevel);
+        metaLevelSubstitution = MetaLevelSubstitution.fromStatementAndReference(statement, reference, context);
 
-        statementUnifiesWithReference = true;
+        const generalContext = context, ///
+              specificContext = context;  ///
+
+        metaLevelSubstitution = metaLevelSubstitution.validate(generalContext, specificContext);  ///
+
+        if (metaLevelSubstitution !== null) {
+          context.addMetaLevelSubstitution(metaLevelSubstitution);
+
+          statementUnifiesWithReference = true;
+        }
       }
     }