occam-verify-cli 1.0.638 → 1.0.642

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.638",
+  "version": "1.0.642",
   "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.121",
+    "occam-grammars": "^1.3.512",
+    "occam-languages": "^0.0.92",
     "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.45",
+    "occam-parsers": "^23.1.42"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",

package/src/context/liminal.js

@@ -77,7 +77,7 @@ export default class LiminalContext extends Context {
     }) || null;
 
     if (substitutionB !== null) {
-      context.trace(`The '${substitutionString}' substitution has already been added to the liminal context.`);
+      context.debug(`The '${substitutionString}' substitution has already been added to the liminal context.`);
     } else {
       this.substitutions.push(substitution);
 

package/src/context/scoped.js

@@ -117,15 +117,15 @@ class ScopedContext extends Context {
 
     const equalityRelfexive = equality.isReflexive();
 
-    if (equalityRelfexive) {
-      context.trace(`The '${equalityString}' equality is reflexive and will not added to the scoped context.`);
-    } else {
+    if (!equalityRelfexive) {
       const { Equivalence } = elements,
             equivalence = Equivalence.fromEquality(equality, context);
 
       this.equivalences = this.equivalences.mergedWithEquivalence(equivalence, context);
 
       context.debug(`...added the '${equalityString}' equality to the scoped context.`);
+    } else {
+      context.debug(`The '${equalityString}' equality is reflexive and will not added to the scoped context.`);
     }
   }
 

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/complexType.js

@@ -41,20 +41,20 @@ export default define(class ComplexTypeDeclaration extends Declaration {
           typePresent = context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
 
     if (typePresent) {
-      context.trace(`The '${typeString}' type is already present.`);
+      context.debug(`The '${typeString}' type is already present.`);
     } else {
       const prefixedTypeName = typeName, ///
             typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
       if (typePresent) {
-        context.trace(`The '${typeString}' type is already present.`);
+        context.debug(`The '${typeString}' type is already present.`);
       } else {
         typeVerifies = true;
       }
     }
 
     if (typeVerifies) {
-      context.trace(`...verified the '${typeString}' complex type.`);
+      context.debug(`...verified the '${typeString}' complex type.`);
     }
 
     return typeVerifies;

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/declaration/simpleType.js

@@ -3,19 +3,29 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
+import { superTypesStringFromSuperTypes } from "../../utilities/string";
 
 export default define(class SimpleTypeDeclaration extends Declaration {
-  constructor(context, string, node, type, prefixed) {
+  constructor(context, string, node, type, prefixed, superTypes) {
     super(context, string, node);
 
     this.type = type;
     this.prefixed = prefixed;
+    this.superTypes = superTypes;
   }
 
   getType() {
     return this.type;
   }
 
+  isPrefixed() {
+    return this.prefixed;
+  }
+
+  getSuperTypes() {
+    return this.superTypes;
+  }
+
   getSimpleTypeDeclarationNode() {
     const node = this.getNode(),
           simpleTypeDeclarationNode = node; ///
@@ -23,71 +33,65 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return simpleTypeDeclarationNode;
   }
 
-  isPrefixed() {
-    return this.prefixed;
-  }
-
   verifyType() {
     let typeVerifies = false;
 
     const context = this.getContext(),
-          typeString = this.type.getString();
+          typeString = this.type.getString(),
+          simpleTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeString}' simple type...`);
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type...`);
 
     const typeName = this.type.getName(),
           includeRelease = true,
           includeDependencies = false,
           typePresent = context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies);
 
-    if (typePresent) {
-      context.trace(`The '${typeString}' type is already present.`);
-    } else {
+    if (!typePresent) {
       const prefixedTypeName = typeName, ///
             typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
-      if (typePresent) {
-        context.trace(`The '${typeString}' type is already present.`);
-      } else {
+      if (!typePresent) {
         typeVerifies = true;
+      } else {
+        context.debug(`The '${typeString}' type is already present.`);
       }
+    } else {
+      context.debug(`The '${typeString}' type is already present.`);
     }
 
     if (typeVerifies) {
-      context.trace(`...verified the '${typeString}' simple type.`);
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type`);
     }
 
     return typeVerifies;
   }
 
-  verifySuperType(superType) {
+  verifySuperType(superType, index) {
     let superTypeVerifies = false;
 
     const context = this.getContext(),
-          superTypeString = superType.getString();
+          superTypeString = superType.getString(),
+          simpleTypeDeclarationString = this.getString(); ///;
 
-    context.trace(`Verifying the '${superTypeString}' super-type...`);
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-types...`);
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
           typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeComparesToTypeName) {
-      context.trace(`The super-type's name compares to the ${typeName}' simple type's name.`);
-    } else {
-      const oldSuperType = superType;
-
+    if (!typeComparesToTypeName) {
       superType = context.findTypeByNominalTypeName(nominalTypeName);
 
-      const superTypePresent = (superType !== null);
-
-      if (superTypePresent) {
-        const newSuperType = superType; ///
-
-        this.type.replaceSuperType(oldSuperType, newSuperType);
+      if (superType !== null) {
+        this.type.replaceSuperType(superType, index);
 
         superTypeVerifies = true;
+      } else {
+        context.debug(`The '${superTypeString}' super-type is not present.`);
       }
+    } else {
+      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
     }
 
     if (superTypeVerifies) {
@@ -100,31 +104,28 @@ export default define(class SimpleTypeDeclaration extends Declaration {
   verifySuperTypes() {
     let superTypesVerify;
 
-    const context = this.getContext(),
-          typeString = this.type.getString();
+    const superTypesLength = this.superTypes.length;
 
-    context.trace(`Verifying the '${typeString}' simple type's super-types...`);
+    if (superTypesLength > 0) {
+      const context = this.getContext(),
+            superTypesString = superTypesStringFromSuperTypes(this.superTypes),
+            simpleTypeDeclarationString = this.getString(); ///;
 
-    const typeBasic = this.type.isBasic();
-
-    if (typeBasic) {
-      superTypesVerify = true;
+      context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types...`);
 
-      context.trace(`The '${typeString}' simple type is basic.`)
-    } else  {
-      const superTypes = this.type.getSuperTypes();
-
-      superTypesVerify = superTypes.every((superType) => {
-        const superTypeVerifies = this.verifySuperType(superType);
+      superTypesVerify = this.superTypes.every((superType, index) => {
+        const superTypeVerifies = this.verifySuperType(superType, index);
 
         if (superTypeVerifies) {
           return true;
         }
       });
-    }
 
-    if (superTypesVerify) {
-      context.debug(`...verified the '${typeString}' simple type's super-types.`);
+      if (superTypesVerify) {
+        context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types.`);
+      }
+    } else {
+      superTypesVerify = true;
     }
 
     return superTypesVerify;
@@ -138,11 +139,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
 
-    if (this.prefixed) {
-      const typeString = this.type.getString();
-
-      context.trace(`The '${typeString}' type is prefixed.`);
-    } else {
+    if (!this.prefixed) {
       const typeVerifies = this.verifyType();
 
       if (typeVerifies) {
@@ -153,7 +150,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
           if (typePrefix !== null) {
             const typePrefixName = typePrefix.getName(),
-              prefixName = typePrefixName;  ///
+                  prefixName = typePrefixName;  ///
 
             this.type.setPrefixName(prefixName);
           }
@@ -163,6 +160,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
           verifies = true;
         }
       }
+    } else {
+      const typeString = this.type.getString();
+
+      context.trace(`The '${typeString}' type is prefixed.`);
     }
 
     if (verifies) {

package/src/element/declaration/typePrefix.js

@@ -40,13 +40,13 @@ export default define(class TypePrefixDeclaration extends Declaration {
             typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
 
       if (typePrefixPresent) {
-        context.trace(`The '${typePrefixString}' type prefix is already present.`);
+        context.debug(`The '${typePrefixString}' type prefix is already present.`);
       } else {
         const nominalTypeName = typePrefixName,  ///
               typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
-          context.trace(`The '${typePrefixString}' type is already present.`);
+          context.debug(`The '${typePrefixString}' type is already present.`);
         } else {
           typePrefixVerifies = true;
         }

package/src/element/declaration/variable.js

@@ -93,7 +93,7 @@ export default define(class VariableDeclaration extends Declaration {
     }
 
     if ( variableVerifies) {
-      context.trace(`...verified the '${variableDeclarationString}' variable declaration's '${variableString}' variable.`);
+      context.debug(`...verified the '${variableDeclarationString}' variable declaration's '${variableString}' variable.`);
     }
 
     return variableVerifies;