occam-verify-cli 1.0.948 → 1.0.949

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.948",
+  "version": "1.0.949",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,12 +12,12 @@
   "dependencies": {
     "argumentative": "^2.0.47",
     "necessary": "^17.1.7",
-    "occam-furtle": "^3.0.205",
+    "occam-furtle": "^3.0.206",
     "occam-grammars": "^1.3.524",
-    "occam-languages": "^0.0.210",
+    "occam-languages": "^0.0.212",
     "occam-lexers": "^23.1.44",
     "occam-model": "^1.0.506",
-    "occam-nominal": "^1.0.109",
+    "occam-nominal": "^1.0.110",
     "occam-parsers": "^23.1.50",
     "occam-server": "^7.0.7"
   },

package/src/element/assertion/contained.js

@@ -113,7 +113,7 @@ export default define(class ContainedAssertion extends Assertion {
       const termSingular = this.term.isSingular();
 
       if (termSingular) {
-        const term = this.term.validate(context, (term) => {
+        const term = this.term.validate(context, (term, context) => {
           const validatesForwards = true;
 
           return validatesForwards;

package/src/element/assertion/defined.js

@@ -104,7 +104,7 @@ export default define(class DefinedAssertion extends Assertion {
       const termSingular = this.term.isSingular();
 
       if (termSingular) {
-        const term = this.term.validate(context, (term) => {
+        const term = this.term.validate(context, (term, context) => {
           const validatesForwards = true;
 
           return validatesForwards;

package/src/element/assertion/property.js

@@ -127,7 +127,7 @@ export default define(class PropertyAssertion extends Assertion {
     context.trace(`Validating the '${propertyAssertionString}' property assertion's term...`);
 
     const type = this.getType(),
-          term = this.term.validate(context, (term) => {
+          term = this.term.validate(context, (term, context) => {
             let validatesForwards = false;
 
             const termType = term.getType(),

package/src/element/assertion/type.js

@@ -123,7 +123,7 @@ export default define(class TypeAssertion extends Assertion {
 
     context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const term = this.term.validate(context, (term) => {
+    const term = this.term.validate(context, (term, context) => {
       let validatesForwards = false;
 
       const termType = term.getType(),
@@ -277,7 +277,7 @@ export default define(class TypeAssertion extends Assertion {
 
 function validateWhenDerived(term, type, context) {
   if (term !== null) {
-    term = term.validate(context, (term) => {
+    term = term.validate(context, (term, context) => {
       let validatesForwards = false;
 
       const termType = term.getType(),

package/src/element/constructor/bracketed.js

@@ -20,7 +20,7 @@ export default define(class BracketedConstructor extends Constructor {
 
     context.trace(`Unifying the '${termString}' term with the bracketed constructor...`);
 
-    termUnifies = super.unifyTerm(term, context, (term) => {
+    termUnifies = super.unifyTerm(term, context, (term, context) => {
       let validatesForwards = false;
 
       const bracketedTerm = term, ///
@@ -34,7 +34,7 @@ export default define(class BracketedConstructor extends Constructor {
 
         bracketlessTerm = termFromTermNode(bracketlessTermNode, context);
 
-        bracketlessTerm = bracketlessTerm.validate(context, (bracketlessTerm) => {  ///
+        bracketlessTerm = bracketlessTerm.validate(context, (bracketlessTerm, context) => {  ///
           let validatesForwards;
 
           const type = bracketlessTerm.getType(),
@@ -44,7 +44,7 @@ export default define(class BracketedConstructor extends Constructor {
 
           bracketedTerm.setProvisional(provisional);
 
-          validatesForwards = validateForwards(bracketedTerm);
+          validatesForwards = validateForwards(bracketedTerm, context);
 
           return validatesForwards;
         });

package/src/element/constructor.js

@@ -8,7 +8,6 @@ import { instantiateConstructor } from "../process/instantiate";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
 import { validateTermAsConstructor } from "../process/validate";
-import { provisionallyStringFromProvisional } from "../utilities/string";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
@@ -123,19 +122,13 @@ export default define(class Constructor extends Element {
           termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);
 
     if (termUnifiesWithConstructor) {
-      let validatesForwards;
-
-      const typeString = this.type.getString(),
-            provisional = this.type.isProvisional(),
-            provisionallyString = provisionallyStringFromProvisional(provisional)
-
-      context.trace(`Setting the '${termString}' term's type to the '${constructorString}' constructor's '${typeString}' type${provisionallyString}.`);
+      const provisional = this.type.isProvisional();
 
       term.setType(this.type);
 
       term.setProvisional(provisional);
 
-      validatesForwards = validateForwards(term);
+      const validatesForwards = validateForwards(term, context);
 
       if (validatesForwards) {
         termUnifies = true;

package/src/element/equality.js

@@ -180,10 +180,10 @@ export default define(class Equality extends Element {
     let leftTerm,
         rightTerm;
 
-    leftTerm = this.leftTerm.validate(context, (leftTerm) => {
+    leftTerm = this.leftTerm.validate(context, (leftTerm, context) => {
         let validatesForwards = false;
 
-        rightTerm = this.rightTerm.validate(context, (rightTerm) => {
+        rightTerm = this.rightTerm.validate(context, (rightTerm, context) => {
           let validatesForwards = false;
 
           const leftTermType = leftTerm.getType(),

package/src/element/metavariable.js

@@ -279,7 +279,7 @@ export default define(class Metavariable extends Element {
         }
       } else {
         if (!strict) {
-          term = this.term.validate(context, (term) => {
+          term = this.term.validate(context, (term, context) => {
             const validatesForwards = true;
 
             return validatesForwards;

package/src/element/property.js

@@ -138,7 +138,7 @@ export default define(class Property extends Element {
     if (validProperty !== null) {
       property = validProperty; ///
 
-      const validatesForward = validateForwards(property);
+      const validatesForward = validateForwards(property, context);
 
       if (validatesForward) {
         validates = true;
@@ -150,7 +150,7 @@ export default define(class Property extends Element {
     } else {
       {
         const property = this,  ///
-              validatesForward = validateForwards(property);
+              validatesForward = validateForwards(property, context);
 
         if (validatesForward) {
           validates = true;
@@ -181,7 +181,7 @@ export default define(class Property extends Element {
 
     let validatesGivenType = false;
 
-    property = this.validate(context, (property) => {
+    property = this.validate(context, (property, context) => {
       let validatesForwards = false;
 
       const propertyName = property.getName(),

package/src/element/propertyRelation.js

@@ -104,7 +104,7 @@ export default define(class PropertyRelation extends Element {
 
     context.trace(`Validating the '${propertyRelationString}' property relation's term...`);
 
-    const term = this.term.validate(context, (term) => {
+    const term = this.term.validate(context, (term, context) => {
       const validatesForwards = true;
 
       return validatesForwards;

package/src/element/signature.js

@@ -151,7 +151,7 @@ export default define(class Signature extends Element {
     const terms = [];
 
     termsValidate = this.terms.every((term) => {
-      term = term.validate(context, (term) => { ///
+      term = term.validate(context, (term, context) => { ///
         const validatesForwards = true;
 
         return validatesForwards;

package/src/element/substitution/term.js

@@ -140,7 +140,7 @@ export default define(class TermSubstitution extends Substitution {
     if (targetTermSingular) {
       manifest((context) => {
         descend((context) => {
-          const targetTerm = this.targetTerm.validate(context, (targetTerm) => {
+          const targetTerm = this.targetTerm.validate(context, (targetTerm, context) => {
             const validatesForwards = true;
 
             return validatesForwards;
@@ -175,7 +175,7 @@ export default define(class TermSubstitution extends Substitution {
     context.trace(`Validating the '${termSubstitutionString}' term substitution's replacement term...`);
 
     descend((context) => {
-      const replacementTerm = this.replacementTerm.validate(context, (replacementTerm) => {
+      const replacementTerm = this.replacementTerm.validate(context, (replacementTerm, context) => {
         const validatesForwards = true;
 
         return validatesForwards;

package/src/element/term.js

@@ -195,7 +195,7 @@ export default define(class Term extends Element {
     if (validTerm !== null) {
       term = validTerm; ///
 
-      const validatesForward = validateForwards(term);
+      const validatesForward = validateForwards(term, context);
 
       if (validatesForward) {
         validates = true;
@@ -238,16 +238,22 @@ export default define(class Term extends Element {
 
     let validatesGivenType = false;
 
-    term = this.validate(context, (term) => {
-      let validatesForwards;
+    term = this.validate(context, (term, context) => {
+      let validatesForwards = false;
 
-      const provisional = type.isProvisional();
+      const termType = term.getType(),
+            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
-      term.setType(type);
+      if (termTypeEqualToOrSubTypeOfType) {
+        validatesForwards = true;
 
-      term.setProvisional(provisional);
+        const typeEstablished = type.isEstablished(),
+              termProvisional = term.isProvisional();
 
-      validatesForwards = true;
+        if (typeEstablished && termProvisional) {
+          validatesForwards = false;
+        }
+      }
 
       return validatesForwards;
     });

package/src/pass/zip.js

@@ -6,8 +6,8 @@ export default class ZipPass extends ZipPassBase {
   run(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
     let success = false;
 
-    const specificChildNodes = specificNonTerminalNode.getChildNodes(), ///
-          generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
+    const generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
+          specificChildNodes = specificNonTerminalNode.getChildNodes(), ///
           descended = this.descend(generalChildNodes, specificChildNodes, ...remainingArguments);
 
     if (descended) {

package/src/process/validate.js

@@ -57,7 +57,7 @@ class CombinatorPass extends SimplePass {
 
         term = termFromTermNode(termNode, context);
 
-        term = term.validate(context, (term) => { ///
+        term = term.validate(context, (term, context) => { ///
           const validatesForwards = true;
 
           return validatesForwards;
@@ -113,7 +113,7 @@ class ConstructorPass extends SimplePass {
 
         term = termFromTermNode(termNode, context);
 
-        term = term.validate(context, (term) => { ///
+        term = term.validate(context, (term, context) => { ///
           const validatesForwards = true;
 
           return validatesForwards;

package/src/utilities/validation.js

@@ -34,7 +34,7 @@ function validateTermAsVariable(term, context, validateForwards) {
 
       term.setProvisional(provisional);
 
-      const validatesForwards = validateForwards(term);
+      const validatesForwards = validateForwards(term, context);
 
       if (validatesForwards) {
         termValidatesAsVariable = true;
@@ -50,24 +50,24 @@ function validateTermAsVariable(term, context, validateForwards) {
 }
 
 function unifyTermWithConstructors(term, context, validateForwards) {
-  let termUnifiesWithConstructors = false;
+  let termUnifiesWithConstructors;
 
   const constructors = context.getConstructors();
 
-  constructors.some((constructor) => {
-    let termUnifies;
+  termUnifiesWithConstructors = constructors.some((constructor) => {
+    let termUnifiesWithConstructor = false;
 
     choose((context) => {
-      termUnifies = constructor.unifyTerm(term, context, validateForwards);
+      const termUnifies = constructor.unifyTerm(term, context, validateForwards);
 
       if (termUnifies) {
+        termUnifiesWithConstructor = true;
+
         context.commit();
       }
     }, context);
 
-    if (termUnifies) {
-      termUnifiesWithConstructors = true;
-
+    if (termUnifiesWithConstructor) {
       return true;
     }
   });