occam-verify-cli 1.0.638 → 1.0.641

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.638",
+  "version": "1.0.641",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -13,13 +13,13 @@
     "argumentative": "^2.0.36",
     "necessary": "^17.0.9",
     "occam-file-system": "^6.0.505",
-    "occam-furtle": "^3.0.116",
-    "occam-grammars": "^1.3.510",
-    "occam-languages": "^0.0.88",
+    "occam-furtle": "^3.0.119",
+    "occam-grammars": "^1.3.512",
+    "occam-languages": "^0.0.90",
     "occam-lexers": "^23.1.34",
-    "occam-model": "^1.0.494",
-    "occam-nominal": "^1.0.42",
-    "occam-parsers": "^23.1.37"
+    "occam-model": "^1.0.496",
+    "occam-nominal": "^1.0.44",
+    "occam-parsers": "^23.1.42"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",

package/src/context.js

@@ -179,6 +179,13 @@ export default class Context extends ContextBase {
     return reference;
   }
 
+  findSubstitutionBySubstitutionNode(substitutionNode) {
+    const context = this.getContext(),
+          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
+
+    return substitution;
+  }
+
   findVariableByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
           variable = context.findVariableByVariableIdentifier(variableIdentifier);

package/src/element/assumption.js

@@ -113,7 +113,7 @@ export default define(class Assumption extends Element {
       }
 
       if (validates) {
-        const assumption = this;  ///
+        assumption = this;  ///
 
         context.addAssumption(assumption);
 

package/src/element/combinator.js

@@ -25,16 +25,15 @@ export default define(class Combinator extends Element {
     return combinatorNode;
   }
 
-  verify() {
+  verify(context) {
     let verifies;
 
-    const context = this.getContext(),
-          combinatorString = this.getString();  ///
+    const combinatorString = this.getString();  ///
 
     context.trace(`Verifying the '${combinatorString}' combinator...`);
 
     const combinator = this,  ///
-          combinatorVerifies = verifyCombinator(combinator, context);
+          combinatorVerifies = verifyCombinator(combinator);
 
     if (combinatorVerifies) {
       verifies = true;

package/src/element/declaration/combinator.js

@@ -30,7 +30,7 @@ export default define(class CombinatorDeclaration extends Declaration {
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerifies = this.combinator.verify();
+    const combinatorVerifies = this.verifyCombinator();
 
     if (combinatorVerifies) {
       context.addCombinator(this.combinator);
@@ -45,5 +45,23 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
+  verifyCombinator() {
+    let combinatorVerifies;
+
+    const context = this.getContext(),
+          combinatorString = this.combinator.getString(),
+          combinatorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);
+
+    combinatorVerifies = this.combinator.verify(context);
+
+    if (combinatorVerifies) {
+      context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator.`);
+    }
+
+    return combinatorVerifies;
+  }
+
   static name = "CombinatorDeclaration";
 });

package/src/element/declaration/constructor.js

@@ -3,77 +3,81 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { validateTerm } from "../../process/validate";
 
 export default define(class ConstructorDeclaration extends Declaration {
-  constructor(context, string, node, constructor) {
+  constructor(context, string, node, type, provisional, constructor) {
     super(context, string, node);
 
+    this.type = type;
+    this.provisional = provisional;
     this.constructor = constructor;
   }
 
+  getType() {
+    return this.type;
+  }
+
+  isProvisinal() {
+    return this.provisional;
+  }
+
   getConstructor() {
     return this.constructor;
   }
 
   getConstructorDeclarationNode() {
     const node = this.getNode(),
-          constructorDeclarationNode = node;  ///
+          constructorDeclarationNode = node; ///
 
     return constructorDeclarationNode;
   }
 
-  verifyConstructor() {
-    let constructorValidates = false;
+  async verify() {
+    let verifies = false;
 
     const context = this.getContext(),
-          constructorString = this.constructor.getString();
+          constructorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    context.trace(`Verifying the '${constructorString}' constructor...`);
+    const typeVerified = this.verifyType();
 
-    const term = this.constructor.getTerm(),
-          termNode = term.getNode(),
-          termValidates = validateTerm(termNode, context, () => {
-            const validatesFormards = true;
+    if (typeVerified) {
+      const constructorVerifies = this.verifyConstructor();
 
-            return validatesFormards;
-          });
+      if (constructorVerifies) {
+        const constructorTypeVerifies = this.verifyConstructorType();
 
-    if (termValidates) {
-      constructorValidates = true;
+        if (constructorTypeVerifies) {
+          context.addConstructor(this.constructor);
+
+          verifies = true;
+        }
+      }
     }
 
-    if (constructorValidates) {
-      context.debug(`...verified the '${constructorString}' constructor.`);
+    if (verifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
     }
 
-    return constructorValidates;
+    return verifies;
   }
 
-  verifyConstructorType() {
-    let constructorTypeVerifies = false;
-
-    const context = this.getContext();
-
-    let type;
+  verifyType() {
+    let typeVerifies = false;
 
-    type = this.constructor.getType();
-
-    const typeString = type.getString();
-
-    context.trace(`Verifying the '${typeString}' type...`);
-
-    const nominalTypeName = type.getNominalTypeName();
+    const context = this.getContext(),
+          typeString = this.type.getString(),
+          constructorDeclarationString = this.getString();  ///
 
-    type = context.findTypeByNominalTypeName(nominalTypeName);
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${typeString}' type...`);
 
-    const typePresent = (type !== null)
+    const nominalTypeName = this.type.getNominalTypeName(),
+          type = context.findTypeByNominalTypeName(nominalTypeName);
 
-    if (!typePresent) {
-      context.debug(`The '${typeString}' type is not present.`);
-    } else {
+    if (type !== null) {
       const includeSupertypes = false,
-            provisional = type.isProvisional(includeSupertypes),
+            provisional = this.isProvisional(includeSupertypes),
             typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
@@ -81,45 +85,104 @@ export default define(class ConstructorDeclaration extends Declaration {
           context.debug(`The '${typeString}' type is present but not provisional.`) :
             context.debug(`The '${typeString}' type is present but provisional.`);
       } else {
-        this.constructor.setType(type);
+        this.type = type;
 
-        constructorTypeVerifies = true;
+        typeVerifies = true;
       }
+    } else {
+      context.debug(`The '${typeString}' type is not present.`);
     }
 
-    if (constructorTypeVerifies) {
-      context.debug(`...verified the '${typeString}' type.`);
+    if (typeVerifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${typeString}' type.`);
     }
 
-    return constructorTypeVerifies;
+    return typeVerifies;
   }
 
-  async verify() {
-    let verifies;
+  verifyConstructor() {
+    let constructorVerifies;
 
     const context = this.getContext(),
-          constructorDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const constructorTypeVerifies = this.verifyConstructorType();
+          constructorString = this.constructor.getString(),
+          constructorDeclarationString = this.getString();  ///
 
-    if (constructorTypeVerifies) {
-      const constructorValidates = this.verifyConstructor();
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
 
-      if (constructorValidates) {
-        context.addConstructor(this.constructor);
+    constructorVerifies = this.constructor.verify(context);
 
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    if (constructorVerifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
     }
 
-    return verifies;
+    return constructorVerifies;
   }
 
+  // verifyConstructorType() {
+  //   let constructorTypeVerifies = false;
+  //
+  //   const context = this.getContext(),
+  //         constructorType = this,
+  //         constructorTypeString = constructorType.getString(),
+  //         constructorDeclarationString = this.getString();  ///
+  //
+  //   context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorTypeString}' type...`);
+  //
+  //   const nominalTypeName = this.type.getNominalTypeName(),
+  //     typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+  //
+  //   if (!typePresent) {
+  //     context.debug(`The '${typeString}' type is not present.`);
+  //   } else {
+  //     const includeSupertypes = false,
+  //       provisional = type.isProvisional(includeSupertypes),
+  //       typeComparesToProvisional = type.compareProvisional(provisional);
+  //
+  //     if (!typeComparesToProvisional) {
+  //       provisional ?
+  //         context.debug(`The '${typeString}' type is present but not provisional.`) :
+  //         context.debug(`The '${typeString}' type is present but provisional.`);
+  //     } else {
+  //       this.constructor.setType(type);
+  //
+  //       constructorTypeVerifies = true;
+  //     }
+  //   }
+  //
+  //   if (constructorTypeVerifies) {
+  //     context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${typeString}' type.`);
+  //   }
+  //
+  //   return constructorTypeVerifies;
+  // }
+
   static name = "ConstructorDeclaration";
 });
+
+
+// verifyConstructor() {
+//   let constructorValidates = false;
+//
+//   const context = this.getContext(),
+//         constructorString = this.constructor.getString();
+//
+//   context.trace(`Verifying the '${constructorString}' constructor...`);
+//
+//   const term = this.constructor.getTerm(),
+//         termNode = term.getNode(),
+//         termValidates = validateTerm(termNode, context, () => {
+//           const validatesFormards = true;
+//
+//           return validatesFormards;
+//         });
+//
+//   if (termValidates) {
+//     constructorValidates = true;
+//   }
+//
+//   if (constructorValidates) {
+//     context.debug(`...verified the '${constructorString}' constructor.`);
+//   }
+//
+//   return constructorValidates;
+// }

package/src/element/equality.js

@@ -120,13 +120,13 @@ export default define(class Equality extends Element {
   }
 
   validate(stated, context) {
-    let equality = false;
+    let equality = null;
 
     const equalityString = this.getString(); ///
 
     context.trace(`Validating the '${equalityString}' equality...`);
 
-    const validEquality = this.isValid(context);
+    const validEquality = this.findValidEquality(context);
 
     if (validEquality !== null) {
       equality = validEquality; ///
@@ -153,7 +153,7 @@ export default define(class Equality extends Element {
       }
 
       if (validates) {
-        const equality = this;  ///
+        equality = this;  ///
 
         this.assign(stated, context);
 
@@ -174,38 +174,36 @@ export default define(class Equality extends Element {
     context.trace(`Validating the '${equalityString}' equality's terms...`);
 
     let leftTerm,
-        rightTerm = null;
+        rightTerm;
 
     leftTerm = this.leftTerm.validate(context, () => {
-        let validatesForwards;
+        let validatesForwards = false;
 
         rightTerm = this.rightTerm.validate(context, () => {
-          let validatesForwards;
-
-          const leftTermType = this.leftTerm.getType(),
-                rightTermType = this.rightTerm.getType(),
-                leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
-
-          validatesForwards = leftTermTypeComparableToRightTermType;  ///
+          const validatesForwards = true;
 
           return validatesForwards;
         });
 
-        const rightTermValidates = (rightTerm !== null);
-
-        validatesForwards = rightTermValidates; ///
+        if (rightTerm !== null) {
+          validatesForwards = true;
+        }
 
         return validatesForwards;
       });
 
-    const leftTermValidates = (leftTerm !== null);
+    if (leftTerm !== null) {
+      const leftTermType = leftTerm.getType(),
+            rightTermType = rightTerm.getType(),
+            leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
 
-    if (leftTermValidates) {
-      this.leftTerm = leftTerm;
+      if (leftTermTypeComparableToRightTermType) {
+        this.leftTerm = leftTerm;
 
-      this.rightTerm = rightTerm;
+        this.rightTerm = rightTerm;
 
-      termsValidate = true;
+        termsValidate = true;
+      }
     }
 
     if (termsValidate) {

package/src/element/frame.js

@@ -64,7 +64,6 @@ export default define(class Frame extends Element {
     return validFrame;
   }
 
-
   isEqualTo(frame) {
     const frameNode = frame.getNode(),
           frameNodeMatches = this.matchFrameNode(frameNode),

package/src/element/judgement.js

@@ -97,7 +97,7 @@ export default define(class Judgement extends Element {
       }
 
       if (validates) {
-        const judgement = this; ///
+        judgement = this; ///
 
         context.addJudgement(judgement)
 

package/src/element/reference.js

@@ -144,7 +144,7 @@ export default define(class Reference extends Element {
       }
 
       if (validates) {
-        const reference = this; ///
+        reference = this; ///
 
         context.addReference(reference);
 

package/src/element/statement.js

@@ -196,7 +196,7 @@ export default define(class Statement extends Element {
       });
 
       if (validates) {
-        const statement = this; ///
+        statement = this; ///
 
         context.addStatement(statement);
 

package/src/element/term.js

@@ -159,9 +159,13 @@ export default define(class Term extends Element {
           valid = (validTerm !== null);
 
     if (valid) {
-      term = validTerm; ///
+      const validatesForward = validateForwards();
 
-      context.debug(`...the '${termString}' term is already valid.`);
+      if (validatesForward) {
+        term = validTerm; ///
+
+        context.debug(`...the '${termString}' term is already valid.`);
+      }
     } else {
       const validates = validateTerms.some((validateTerm) => {  ///
         const term = this,  ///
@@ -173,7 +177,7 @@ export default define(class Term extends Element {
       });
 
       if (validates) {
-        term = null;  ///
+        term = this;  ///
 
         context.addTerm(term);