occam-verify-cli 1.0.642 → 1.0.648

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/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();

package/src/node/declaration/simpleType.js

@@ -6,13 +6,6 @@ import { PROVISIONAL } from "../../constants";
 import { TYPE_RULE_NAME, TYPES_RULE_NAME } from "../../ruleNames";
 
 export default class SimpleTypeDeclarationNode extends DeclarationNode {
-  isPrefixed() {
-    const typeNode = this.getTypeNode(),
-          prefixed = typeNode.isPrefixed();
-
-    return prefixed;
-  }
-
   isProvisional() {
     let provisional = false;
 

package/src/process/assign.js

@@ -55,32 +55,24 @@ export function rightVariableAssignmentFromEquality(equality, context) {
 }
 
 export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
+  let variableAssignment = null;
 
-  debugger
+  const term = typeAssertion.getTerm(),
+        termSingular = term.isSingular();
 
-  // const { Type, Variable } = elements,
-  //   termNode = this.term.getNode();
-  //
-  // let type,
-  //   provisional;
-  //
-  // provisional = this.type.isProvisional();
-  //
-  // if (!provisional) {
-  //   type = this.type;
-  // } else {
-  //   provisional = false;
-  //
-  //   type = Type.fromTypeAndProvisional(this.type, provisional);
-  // }
-  //
-  // const singularVariableNode = termNode.getSingularVariableNode();
-  //
-  // if (singularVariableNode !== null) {
-  //   const variableNode = singularVariableNode,  ///
-  //     variable = Variable.fromVariableNodeAndType(variableNode, type, context),
-  //     variableAssignment = variableAssignmentFromVariable(variable),
+  if (termSingular) {
+    const variableIdentifier = term.getVariableIdentifier(),
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+    if (variable !== null) {
+      const type = typeAssertion.getType(),
+            variableNode = variable.getNode();
 
+      variableAssignment = variableAssignmentFromVariableNodeAndType(variableNode, type, context);
+    }
+  }
+
+  return variableAssignment;
 }
 
 export function variableAssignmentFromPrepertyAssertion(propertyAssertion, context) {

package/src/process/unify.js

@@ -145,6 +145,22 @@ class MetaLevelPass extends ZipPass {
 }
 
 class CombinatorPass extends ZipPass {
+  run(combinatorStatementNode, statementNode, stated, generalContext, specificContext) {
+    let success = false;
+
+    const specificnonTerminalNode = statementNode,  ///
+          generalcnonTerminalNode = combinatorStatementNode,  ///
+          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
+          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalcChildNodes, specificChildNodes, stated, generalContext, specificContext);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       generalNodeQuery: metaTypeNodeQuery,
@@ -236,6 +252,22 @@ class CombinatorPass extends ZipPass {
 }
 
 class ConstructorPass extends ZipPass {
+  run(constructorTermNode, termNode, generalContext, specificContext) {
+    let success = false;
+
+    const specificnonTerminalNode = termNode,  ///
+          generalcnonTerminalNode = constructorTermNode,  ///
+          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
+          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalcChildNodes, specificChildNodes, generalContext, specificContext);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       generalNodeQuery: typeNodeQuery,

package/src/process/verify.js

@@ -288,6 +288,20 @@ class TopLevelPass extends AsyncPass {
 }
 
 class ConbinatorPass extends SimplePass {
+  run(statementNode, context) {
+    let success = false;
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       nodeQuery: statementNodeQuery,
@@ -350,6 +364,20 @@ class ConbinatorPass extends SimplePass {
 }
 
 class ConstructorPass extends SimplePass {
+  run(termNode, context) {
+    let success = false;
+
+    const nonTerminalNode = termNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       nodeQuery: termNodeQuery,
@@ -408,26 +436,28 @@ export async function verifyFile(fileNode, context) {
   return fileVerifies;
 }
 
-export function verifyCombinator(combintot) {
-  const context = combintot.getContext(),
-        statement = combintot.getStatement(),
-        statementNode = statement.getNode(),
-        nonTerminalNode = statementNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        descended = combinatorPass.descend(childNodes, context),
-        combinatorVerifies = descended;  ///
+export function verifyTermAsConstructor(term, context) {
+  let termVerifiesAsConstructor = false;
 
-  return combinatorVerifies;
+  const termNode = term.getNode(),
+        success = constructorPass.run(termNode, context);
+
+  if (success) {
+    termVerifiesAsConstructor = true;
+  }
+
+  return termVerifiesAsConstructor;
 }
 
-export function verifyConstrcctor(constructor) {
-  const context = constructor.getContext(),
-        term = constructor.getStatement(),
-        termNode = term.getNode(),
-        nonTerminalNode = termNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        descended = constructorPass.descend(childNodes, context),
-        constrcctorVerifies = descended;  ///
+export function verifyStatementAsCombinator(statement, context) {
+  let statementVerifiesAsCombinator = false;
+
+  const statementNode = statement.getNode(),
+        success = combinatorPass.run(statementNode, context);
+
+  if (success) {
+    statementVerifiesAsCombinator = true;
+  }
 
-  return constrcctorVerifies;
+  return statementVerifiesAsCombinator;
 }

package/src/utilities/element.js

@@ -741,9 +741,9 @@ export function simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDec
         node = simpleTypeDeclarationNode, ///
         string = context.nodeAsString(node),
         type = typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-        prefixed = prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
         superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-        simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, node, type, prefixed, superTypes);
+        provisional = provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+        simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, node, type, superTypes, provisional);
 
   return simpleTypeDeclaration;
 }
@@ -789,8 +789,9 @@ export function complexTypeDeclarationFromComplexTypeDeclarationNode(complexType
         node = complexTypeDeclarationNode,  ///
         string = context.nodeAsString(node),
         type = typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        prefixed = prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, type, prefixed);
+        superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, type, superTypes, provisional);
 
   return complexTypeDeclaration;
 }
@@ -1584,12 +1585,6 @@ export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, co
   return suppositions;
 }
 
-export function prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  const prefixed = simpleTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
 export function resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context) {
   const resolved = statementSubstitutionNode.isResolved();
 
@@ -1603,12 +1598,6 @@ export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode,
   return deduction;
 }
 
-export function prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const prefixed = complexTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
 export function procedureReferenceFromProcedureCallNode(procedureCallNode, context) {
   const procedureReferenceNode = procedureCallNode.getProcedureReferenceNode(),
         procedureReference = procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context);
@@ -1658,12 +1647,26 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
-export function provisionalFromConstructorDeclarationNode(constructorDeclarationNode, context) {
-  const provisional = constructorDeclarationNode.isProvisional();
+export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+  const provisional = simpleTypeDeclarationNode.isProvisional();
 
   return provisional;
 }
 
+export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  let superTypes = [];
+
+  const typesNode = complexTypeDeclarationNode.getTypesNode();
+
+  if (typesNode !== null) {
+    const types = typesFromTypesNode(typesNode, context);
+
+    superTypes = types; ///
+  }
+
+  return superTypes;
+}
+
 export function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode(),
         replacementFrame = frameFromFrameNode(replacementFrameNode, context);
@@ -1700,6 +1703,18 @@ export function constructorFromConstructorDeclarationNode(constructorDeclaration
   return constructor;
 }
 
+export function provisionalFromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  const provisional = constructorDeclarationNode.isProvisional();
+
+  return provisional;
+}
+
+export function provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const provisional = complexTypeDeclarationNode.isProvisional();
+
+  return provisional;
+}
+
 export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   const metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
         metavariable = metavariableFromMetavariableNode(metavariableNode, context);

package/src/utilities/type.js

@@ -10,10 +10,9 @@ export function baseTypeFromNothing() {
   if (baseType === null) {
     const { Type } = elements,
           name = BASE_TYPE_SYMBOL,  ///
-          context = null,
-          provisional = false;
+          context = null;
 
-    baseType = Type.fromNameAndProvisional(name, provisional, context);
+    baseType = Type.fromName(name, context);
   }
 
   return baseType;