occam-verify-cli 1.0.642 → 1.0.649

package/src/element/conclusion.js

@@ -87,26 +87,10 @@ export  default define(class Conclusion extends Element {
   }
 
   toJSON() {
-    let frames,
-        terms;
-
-    frames = this.context.getFrames();
-
-    terms = this.context.getTerms();
-
     const statementJSON = statementToStatementJSON(this.statement),
-          framesJSON = framesToFramesJSON(frames),
-          termsJSON = termsToTermsJSON(terms);
-
-    frames = framesJSON;  ///
-
-    terms = termsJSON;  ///
-
-    const statement = statementJSON,  ///
+          statement = statementJSON,  ///
           json = {
-            statement,
-            frames,
-            terms
+            statement
           };
 
     return json;
@@ -115,14 +99,6 @@ export  default define(class Conclusion extends Element {
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          node = null,
-          string = statement.getString();
-
-    context = ephemeralContext; ///
-
-    const conclusion = new Conclusion(context, string, node, statement);
-
-    return conclusion;
+    debugger
   }
 });

package/src/element/constructor.js

@@ -3,6 +3,8 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { attempt } from "../utilities/context";
+import { verifyTermAsConstructor } from "../process/verify";
 import { unifyTermWithConstructor } from "../process/unify";
 import { termFromJSON, termToTermJSON } from "../utilities/json";
 
@@ -24,12 +26,53 @@ export default define(class Constructor extends Element {
     return constructorNode;
   }
 
-  isProvisional() { return this.term.isProvisional(); }
-
   getType() { return this.term.getType(); }
 
+  getString() {
+    let string;
+
+    const type = this.getType();
+
+    if (type === null) {
+      const termString = this.term.getString();
+
+      string = termString;  ///
+    } else {
+      const typeString = type.getString(),
+            termString = this.term.getString();
+
+      string = `${termString}.${typeString}`;
+    }
+
+    return string;
+  }
+
   setType(type) { this.term.setType(type); }
 
+  verify(context) {
+    let verifies = false;
+
+    const constructorString = this.getString();  ///
+
+    context.trace(`Verifying the '${constructorString}' constructor...`);
+
+    attempt((context) => {
+      const termVerifiesAsConstructor = verifyTermAsConstructor(this.term, context);
+
+      if (termVerifiesAsConstructor) {
+        this.setContext(context);
+
+        verifies = true;
+      }
+    }, context);
+
+    if (verifies) {
+      context.debug(`...verified the '${constructorString}' constructor.`);
+    }
+
+    return verifies;
+  }
+
   unifyTerm(term, context, validateForwards) {
     let termUnifies = false;
 
@@ -38,8 +81,16 @@ export default define(class Constructor extends Element {
 
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 
+    const specifiContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specifiContext; ///
+
     const constructor = this, ///
-          termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
+          termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);
 
     if (termUnifiesWithConstructor) {
       let validatesForwards;

package/src/element/declaration/combinator.js

@@ -25,8 +25,11 @@ export default define(class CombinatorDeclaration extends Declaration {
   async verify() {
     let verifies = false;
 
-    const context = this.getContext(),
-          combinatorDeclarationString = this.getString();  ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const combinatorDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 

package/src/element/declaration/complexType.js

@@ -5,19 +5,19 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class ComplexTypeDeclaration extends Declaration {
-  constructor(context, string, node, type, prefixed) {
+  constructor(context, string, node, type, 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;
   }
 
   getComplexTypeDeclarationNode() {
@@ -266,8 +266,11 @@ export default define(class ComplexTypeDeclaration extends Declaration {
   async verify() {
     let verifies = false;
 
-    const context = this.getContext(),
-          complexTypeDeclarationString = this.getString(); ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const complexTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
 

package/src/element/declaration/constructor.js

@@ -17,7 +17,7 @@ export default define(class ConstructorDeclaration extends Declaration {
     return this.type;
   }
 
-  isProvisinal() {
+  isProvisional() {
     return this.provisional;
   }
 
@@ -32,37 +32,6 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorDeclarationNode;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext(),
-          constructorDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const typeVerified = this.verifyType();
-
-    if (typeVerified) {
-      const constructorVerifies = this.verifyConstructor();
-
-      if (constructorVerifies) {
-        const constructorTypeVerifies = this.verifyConstructorType();
-
-        if (constructorTypeVerifies) {
-          context.addConstructor(this.constructor);
-
-          verifies = true;
-        }
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
-
-    return verifies;
-  }
-
   verifyType() {
     let typeVerifies = false;
 
@@ -76,8 +45,7 @@ export default define(class ConstructorDeclaration extends Declaration {
           type = context.findTypeByNominalTypeName(nominalTypeName);
 
     if (type !== null) {
-      const includeSupertypes = false,
-            provisional = this.isProvisional(includeSupertypes),
+      const provisional = this.isProvisional(),
             typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
@@ -118,71 +86,37 @@ export default define(class ConstructorDeclaration extends Declaration {
     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;
-  // }
+  async verify() {
+    let verifies = false;
 
-  static name = "ConstructorDeclaration";
-});
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const constructorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+
+    const typeVerified = this.verifyType();
+
+    if (typeVerified) {
+      const constructorVerifies = this.verifyConstructor();
+
+      if (constructorVerifies) {
+        this.constructor.setType(this.type);
+
+        context.addConstructor(this.constructor);
 
+        verifies = true;
+      }
+    }
 
-// 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;
-// }
+    if (verifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    }
+
+    return verifies;
+  }
+
+  static name = "ConstructorDeclaration";
+});

package/src/element/declaration/simpleType.js

@@ -4,28 +4,29 @@ import Declaration from "../declaration";
 
 import { define } from "../../elements";
 import { superTypesStringFromSuperTypes } from "../../utilities/string";
+import {baseTypeFromNothing} from "../../utilities/type";
 
 export default define(class SimpleTypeDeclaration extends Declaration {
-  constructor(context, string, node, type, prefixed, superTypes) {
+  constructor(context, string, node, type, superTypes, provisional) {
     super(context, string, node);
 
     this.type = type;
-    this.prefixed = prefixed;
     this.superTypes = superTypes;
+    this.provisional = provisional;
   }
 
   getType() {
     return this.type;
   }
 
-  isPrefixed() {
-    return this.prefixed;
-  }
-
   getSuperTypes() {
     return this.superTypes;
   }
 
+  isProvisional() {
+    return this.provisional;
+  }
+
   getSimpleTypeDeclarationNode() {
     const node = this.getNode(),
           simpleTypeDeclarationNode = node; ///
@@ -52,6 +53,8 @@ export default define(class SimpleTypeDeclaration extends Declaration {
             typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);
 
       if (!typePresent) {
+        this.type.setProvisional(this.provisional);
+
         typeVerifies = true;
       } else {
         context.debug(`The '${typeString}' type is already present.`);
@@ -67,14 +70,14 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifySuperType(superType, index) {
+  verifySuperType(superType, superTypes) {
     let superTypeVerifies = false;
 
     const context = this.getContext(),
           superTypeString = superType.getString(),
           simpleTypeDeclarationString = this.getString(); ///;
 
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-types...`);
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-type...`);
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
@@ -84,7 +87,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
       superType = context.findTypeByNominalTypeName(nominalTypeName);
 
       if (superType !== null) {
-        this.type.replaceSuperType(superType, index);
+        superTypes.push(superType);
 
         superTypeVerifies = true;
       } else {
@@ -95,7 +98,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     }
 
     if (superTypeVerifies) {
-      context.debug(`...verified the '${superTypeString}' super-type.`);
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-type.`);
     }
 
     return superTypeVerifies;
@@ -104,66 +107,92 @@ export default define(class SimpleTypeDeclaration extends Declaration {
   verifySuperTypes() {
     let superTypesVerify;
 
-    const superTypesLength = this.superTypes.length;
+    const context = this.getContext(),
+          superTypes = [],
+          superTypesString = superTypesStringFromSuperTypes(this.superTypes),
+          simpleTypeDeclarationString = this.getString(); ///;
 
-    if (superTypesLength > 0) {
-      const context = this.getContext(),
-            superTypesString = superTypesStringFromSuperTypes(this.superTypes),
-            simpleTypeDeclarationString = this.getString(); ///;
+    (superTypesString !== null) ?
+      context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types...`) :
+        context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's super-types...`);
 
-      context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types...`);
+    superTypesVerify = this.superTypes.every((superType) => {
+      const superTypeVerifies = this.verifySuperType(superType, superTypes);
 
-      superTypesVerify = this.superTypes.every((superType, index) => {
-        const superTypeVerifies = this.verifySuperType(superType, index);
+      if (superTypeVerifies) {
+        return true;
+      }
+    });
 
-        if (superTypeVerifies) {
-          return true;
-        }
-      });
+    if (superTypesVerify) {
+      const superTypesLength = superTypes.length;
 
-      if (superTypesVerify) {
-        context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types.`);
+      if (superTypesLength === 0) {
+        const baseType = baseTypeFromNothing(),
+          superTyupe = baseType;  ///
+
+        superTypes.push(superTyupe);
       }
-    } else {
-      superTypesVerify = true;
+
+      this.type.setSuperTypes(superTypes);
+
+      (superTypesString !== null) ?
+        context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${superTypesString}' super-types.`) :
+          context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's super-types.`);
     }
 
     return superTypesVerify;
   }
 
+  verifyTypePrefix() {
+    let typePrefixVerifies = false;
+
+    const context = this.getContext(),
+          typeString = this.type.getString(),
+          simpleTypeDeclarationString = this.getString(); ///;
+
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix...`);
+
+    const typePrefixed = this.type.isPrefixed();
+
+    if (!typePrefixed) {
+      typePrefixVerifies = true;
+    } else {
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type is prefixed.`);
+    }
+
+    if (typePrefixVerifies) {
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix.`);
+    }
+
+    return typePrefixVerifies;
+  }
+
   async verify() {
     let verifies = false;
 
-    const context = this.getContext(),
-          simpleTypeDeclarationString = this.getString();  ///
+    const context = this.getContext();
 
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
+    await this.break(context);
 
-    if (!this.prefixed) {
-      const typeVerifies = this.verifyType();
+    const simpleTypeDeclarationString = this.getString();  ///
 
-      if (typeVerifies) {
-        const superTypesVerify = this.verifySuperTypes();
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
 
-        if (superTypesVerify) {
-          const typePrefix = context.getTypePrefix();
+    const typeVerifies = this.verifyType();
 
-          if (typePrefix !== null) {
-            const typePrefixName = typePrefix.getName(),
-                  prefixName = typePrefixName;  ///
+    if (typeVerifies) {
+      const superTypesVerify = this.verifySuperTypes();
 
-            this.type.setPrefixName(prefixName);
-          }
+      if (superTypesVerify) {
+        const typePrefixVerifies = this.verifyTypePrefix();
 
+        if (typePrefixVerifies) {
           context.addType(this.type);
 
           verifies = true;
         }
       }
-    } else {
-      const typeString = this.type.getString();
-
-      context.trace(`The '${typeString}' type is prefixed.`);
     }
 
     if (verifies) {

package/src/element/declaration/typePrefix.js

@@ -63,8 +63,11 @@ export default define(class TypePrefixDeclaration extends Declaration {
   async verify() {
     let verifies = false;
 
-    const context = this.getContext(),
-          typePrefixDeclarationString = this.getString();  ///
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const typePrefixDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
 

package/src/element/declaration/variable.js

@@ -79,20 +79,15 @@ export default define(class VariableDeclaration extends Declaration {
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${variableString}' variable...`);
 
     const variableIdentifier = this.variable.getIdentifier(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier),
-          variablePresent = (variable !== null);
+          variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
     if (variablePresent) {
-      const variableIdentifier = variable.getIdentifier();
-
-      context.debug(`The '${variableIdentifier}' variable is already present.`);
+      context.debug(`The '${variableString}' variable is already present.`);
     } else {
-      this.variable.setType(this.type);
-
       variableVerifies = true;
     }
 
-    if ( variableVerifies) {
+    if (variableVerifies) {
       context.debug(`...verified the '${variableDeclarationString}' variable declaration's '${variableString}' variable.`);
     }
 

package/src/element/metavariable.js

@@ -453,6 +453,6 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    ///
+    debugger
   }
 });

package/src/element/statement.js

@@ -345,6 +345,6 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   static fromJSON(json, context) {
-    ///
+    debugger
   }
 });

package/src/element/term.js

@@ -197,16 +197,16 @@ export default define(class Term extends Element {
     context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
     const validates = this.validate(context, () => {
-            let validatesForwards;
+      let validatesForwards;
 
-            const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
+      const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
 
-            if (typeEqualToOrSubTypeOfGivenTypeType) {
-              validatesForwards = true;
-            }
+      if (typeEqualToOrSubTypeOfGivenTypeType) {
+        validatesForwards = true;
+      }
 
-            return validatesForwards;
-          });
+      return validatesForwards;
+    });
 
     if (validates) {
       validatesGivenType = true;

package/src/element/topLevelAssertion/axiom.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import TopLevelAssertion  from "../../node/topLevelAssertion";
+import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
 

package/src/element/type.js

@@ -233,12 +233,12 @@ export default define(class Type extends Element {
     return comparesToTypeName;
   }
 
-  compareProvisional(provisional) {
+  compareProvisional(provisional, includeSupertypes = true) {
     let comparesToProvisional;
 
     const provisionalA = provisional; ///
 
-    provisional = this.isProvisional();
+    provisional = this.isProvisional(includeSupertypes);
 
     const provisionalB = provisional; ///
 
@@ -326,12 +326,13 @@ export default define(class Type extends Element {
     return type;
   }
 
-  static fromNameAndProvisional(name, provisional, context) {
+  static fromName(name, context) {
     const string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
+          provisional = false,
           type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;

package/src/node/declaration/complexType.js

@@ -28,13 +28,6 @@ export default class ComplexTypeDeclarationNode extends DeclarationNode {
     return provisional;
   }
 
-  isPrefixed() {
-    const typeNode = this.getTypeNode(),
-          prefixed = typeNode.isPrefixed();
-
-    return prefixed;
-  }
-
   getTypeName() {
     const typeNode = this.getTypeNode(),
           typeName = typeNode.getTypeName();