occam-verify-cli 1.0.165 → 1.0.168

package/src/dom/type.js

@@ -4,11 +4,12 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { PROVISIONAL } from "../constants";
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { typeNameFromTypeNode } from "../utilities/name";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import { PROVISIONAL, PROVISIONALLY } from "../constants";
+import { superTypesStringFromSuperTypes } from "../utilities/type";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
@@ -17,10 +18,11 @@ const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type"),
       typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type"),
       propertyDeclarationNodesQuery = nodesQuery("/complexTypeDeclaration/propertyDeclaration"),
       propertyDeclarationTypeNodeQuery = nodeQuery("/propertyDeclaration/type"),
+      variableDeclarationTypeNodeQuery = nodeQuery("/variableDeclaration/type"),
       typeDeclarationSuperTypeNodesQuery = nodesQuery("/typeDeclaration|complexTypeDeclaration/types/type"),
-      firstPrimaryKeywordTerminalNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/@primary-keyword[0]"),
-      variableDeclarationSuperTypeNodeQuery = nodeQuery("/variableDeclaration/type"),
-      constructorDeclarationSuperTypeNodeQuery = nodeQuery("/constructorDeclaration/type");
+      constructorDeclarationSuperTypeNodeQuery = nodeQuery("/constructorDeclaration/type"),
+      firstTypeDeclarationPrimaryKeywordTerminalNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/@primary-keyword[0]"),
+      lastVariableDeclarationSecondaryKeywordTerminalNodeQuery = nodeQuery("/variableDeclaration/@secondary-keyword[-1]");
 
 class Type {
   constructor(string, name, superTypes, properties, provisional) {
@@ -77,20 +79,6 @@ class Type {
     return provisional;
   }
 
-  getSoleSuperType() {
-    let soleSuperType = null;
-
-    const superTypesLength = this.superTypes.length;
-
-    if (superTypesLength === 1) {
-      const firstSuperType = first(this.superTypes);
-
-      soleSuperType = firstSuperType; ///
-    }
-
-    return soleSuperType;
-  }
-
   setString(string) {
     this.string = string;
   }
@@ -111,36 +99,22 @@ class Type {
     this.provisional = provisional;
   }
 
-  isRefined() {
-    let refined = false;
-
-    const soleSuperType = this.getSoleSuperType();
-
-    if (soleSuperType !== null) {
-      const soleSuperTypeNameMatchesName = soleSuperType.matchName(this.name);
-
-      refined = soleSuperTypeNameMatchesName; ///
-    }
-
-    return refined;
-  }
-
   isBasic() {
-    let basic = false;
-
-    const soleSuperType = this.getSoleSuperType();
-
-    if (soleSuperType !== null) {
-      const soleSuperTypeObjectType = (soleSuperType === objectType);
-
-      basic = soleSuperTypeObjectType;  ///
-    }
+    const basic = basicFromSuperTypes(this.superTypes);
 
     return basic;
   }
 
   isEqualTo(type) {
-    const equalTo = (this === type);
+    let equalTo = false;
+
+    if (this.type === type) {
+      equalTo = true;
+    } else {
+      if (type.name === null) {
+
+      }
+    }
 
     return equalTo;
   }
@@ -211,6 +185,20 @@ class Type {
     return typeNameMatches;
   }
 
+  matchProvisional(provisional) {
+    let provisionalMatches;
+
+    const provisionalA = provisional; ///
+
+    provisional = this.isProvisional();
+
+    const provisionalB = provisional; ///
+
+    provisionalMatches = (provisionalA === provisionalB);
+
+    return provisionalMatches;
+  }
+
   toJSON() {
     const propertiesJSON = propertiesToPropertiesJSON(this.properties),
           superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
@@ -269,11 +257,11 @@ class Type {
   }
 
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-    const provisional = provisionalFromTypeDeclarationNode(typeDeclarationNode, fileContext),
+    const properties = [],
+          provisional = provisionalFromTypeDeclarationNode(typeDeclarationNode, fileContext),
           superTypes = superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext),
           name = nameFromTypeDeclarationNode(typeDeclarationNode, fileContext),
           string = stringFromNameAndSuperTypes(name, superTypes),
-          properties = [],
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
@@ -288,9 +276,12 @@ class Type {
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    const variableDeclarationSuperTypeNode = variableDeclarationSuperTypeNodeQuery(variableDeclarationNode),
-          typeNode = variableDeclarationSuperTypeNode,  ///
-          type = typeFromTypeNode(typeNode, fileContext);
+    const properties = null,
+          superTypes = null,
+          provisional = provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext),
+          name = nameFromVariableDeclarationNode(variableDeclarationNode, fileContext),
+          string = stringFromName(name),
+          type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
   }
@@ -304,10 +295,10 @@ class Type {
   }
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-    const provisional = provisionalFromTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+    const properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          provisional = provisionalFromTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          name = nameFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          name = nameFromComplexTypeDeclaration(complexTypeDeclarationNode, fileContext),
           string = stringFromNameAndSuperTypes(name, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
@@ -317,6 +308,14 @@ class Type {
 
 export default domAssigned(Type);
 
+function stringFromName(name) {
+  const string = (name !== null) ?
+                   name :
+                     OBJECT_TYPE_NAME;
+
+  return string;
+}
+
 function typeFromTypeNode(typeNode, fileContext) {
   let type;
 
@@ -337,13 +336,34 @@ function typeFromTypeNode(typeNode, fileContext) {
   return type;
 }
 
+function basicFromSuperTypes(superTypes) {
+  let basic = false;
+
+  const superTypesLength = superTypes.length;
+
+  if (superTypesLength === 1) {
+    const firstSuperType = first(superTypes),
+          superType = firstSuperType; ///
+
+    if (superType === objectType) {
+      basic = true;
+    }
+  }
+
+  return basic;
+}
+
 function stringFromNameAndSuperTypes(name, superTypes) {
-  let string = name;  ///
+  let string;
 
-  const superTypesString = superTypesStringFromSuperTypes(superTypes);
+  if (name === null) {
+    string = OBJECT_TYPE_NAME;  ///
+  } else {
+    const superTypesString = superTypesStringFromSuperTypes(superTypes);
 
-  if (superTypesString !== null) {
-    string = `${string}:${superTypesString}`;
+    string = (superTypesString !== null) ?
+               `${name}:${superTypesString}` :
+                  name; ///
   }
 
   return string;
@@ -358,20 +378,28 @@ function nameFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   return name;
 }
 
-function superTypesStringFromSuperTypes(superTypes) {
-  const superTypesString = superTypes.reduce((superTypesString, superType) => {
-    if (superType !== objectType) {
-      const superTypeName = superType.getName();
+function nameFromComplexTypeDeclaration(complexTypeDeclarationNode, fileContext) {
+  const typeDeclarationTypeNode = typeDeclarationTypeNodeQuery(complexTypeDeclarationNode),
+        typeNode = typeDeclarationTypeNode, ///
+        typeName = typeNameFromTypeNode(typeNode),
+        name = typeName;  ///
+
+  return name;
+}
+
+function nameFromVariableDeclarationNode(variableDeclarationNode, fileContext) {
+  let name = null;
 
-      superTypesString = (superTypesString === null) ?
-                           superTypeName :
-                            `${superTypesString}, ${superTypeName}`;
-    }
+  const variableDeclarationTypeNode = variableDeclarationTypeNodeQuery(variableDeclarationNode);
 
-    return superTypesString;
-  }, null);
+  if (variableDeclarationTypeNode !== null) {
+    const typeNode = variableDeclarationTypeNode, ///
+          typeName = typeNameFromTypeNode(typeNode);
 
-  return superTypesString;
+    name = typeName;  ///
+  }
+
+  return name;
 }
 
 function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
@@ -392,21 +420,27 @@ function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
 }
 
 function provisionalFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-  const firstPrimaryKeywordTerminalNode = firstPrimaryKeywordTerminalNodeQuery(typeDeclarationNode),
-        content = firstPrimaryKeywordTerminalNode.getContent(),
+  const firstTypeDeclarationPrimaryKeywordTerminalNode = firstTypeDeclarationPrimaryKeywordTerminalNodeQuery(typeDeclarationNode),
+        content = firstTypeDeclarationPrimaryKeywordTerminalNode.getContent(),
         contentProvisional = (content === PROVISIONAL),
         provisional = contentProvisional; ///
 
   return provisional;
 }
 
-function nameFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-  const typeDeclarationTypeNode = typeDeclarationTypeNodeQuery(complexTypeDeclarationNode),
-        typeNode = typeDeclarationTypeNode, ///
-        typeName = typeNameFromTypeNode(typeNode),
-        name = typeName;  ///
+function provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext) {
+  let provisional = false;
 
-  return name;
+  const lastVariableDeclarationSecondaryKeywordTerminalNode = lastVariableDeclarationSecondaryKeywordTerminalNodeQuery(variableDeclarationNode);
+
+  if (lastVariableDeclarationSecondaryKeywordTerminalNode !== null) {
+    const content = lastVariableDeclarationSecondaryKeywordTerminalNode.getContent(),
+          contentProvisional = (content === PROVISIONALLY);
+
+    provisional = contentProvisional; ///
+  }
+
+  return provisional;
 }
 
 function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
@@ -445,24 +479,21 @@ class ObjectType extends Type {
     return properties;
   }
 
-  toJSON() {
-    const name = this.name,
-          superTypes = [],
-          properties = this.properties,
-          provisional = this.provisional,
-          json = {
-            name,
-            superTypes,
-            properties,
-            provisional
-          };
-
-    return json;
-  }
+  // matchName(name) {
+  //   const nameMatches = ((name === null) || (name === OBJECT_TYPE_NAME));
+  //
+  //   return nameMatches;
+  // }
+  //
+  // matchTypeName(typeName) {
+  //   const typeNameMatches = ((typeName === null) || (typeName === OBJECT_TYPE_NAME));
+  //
+  //   return typeNameMatches;
+  // }
 
   static fromNothing() {
-    const name = OBJECT_TYPE_NAME,
-          string = name,  //
+    const name = null,
+          string = OBJECT_TYPE_NAME,  ///
           superTypes = [],
           properties = [],
           provisional = false,

package/src/dom/variable.js

@@ -7,22 +7,20 @@ import TermSubstitution from "../substitution/term";
 import { nodeQuery } from "../utilities/query";
 import { ObjectType } from "./type";
 import { domAssigned } from "../dom";
-import { EMPTY_STRING, PROVISIONALLY } from "../constants";
+import { EMPTY_STRING } from "../constants";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { variableNameFromVariableNode } from "../utilities/name";
 import { variableNodeFromVariableString } from "../context/partial/variable";
 
 const termVariableNodeQuery = nodeQuery("/term/variable!"),
-      variableDeclarationVariableNodeQuery = nodeQuery("/variableDeclaration/variable"),
-      lastSecondaryKeywordTerminalNodeQuery = nodeQuery("/variableDeclaration/@secondary-keyword[-1]");
+      variableDeclarationVariableNodeQuery = nodeQuery("/variableDeclaration/variable");
 
 export default domAssigned(class Variable {
-  constructor(string, node, name, type, provisional, propertyRelations) {
+  constructor(string, node, name, type, propertyRelations) {
     this.string = string;
     this.node = node;
     this.name = name;
     this.type = type;
-    this.provisional = provisional;
     this.propertyRelations = propertyRelations;
   }
 
@@ -42,10 +40,6 @@ export default domAssigned(class Variable {
     return this.type;
   }
 
-  isProvisional() {
-    return this.provisional;
-  }
-
   getPropertyRelations() {
     return this.propertyRelations;
   }
@@ -54,10 +48,6 @@ export default domAssigned(class Variable {
     this.type = type;
   }
 
-  setProvisional(provisional) {
-    this.provisional = provisional;
-  }
-
   isEqualTo(variable) {
     const variableString = variable.getString(),
           equalTo = (variableString === this.string);
@@ -124,26 +114,22 @@ export default domAssigned(class Variable {
   verifyType(fileContext) {
     let typeVerified = false;
 
-    if (this.type === ObjectType) {
-      typeVerified = true;
-    } else {
-      const typeName = this.type.getName();
+    const typeString = this.type.getString();
 
-      fileContext.trace(`Verifying the '${typeName}' type...`);
+    fileContext.trace(`Verifying the '${typeString}' type...`);
 
-      const type = fileContext.findTypeByTypeName(typeName);
+    const type = fileContext.findTypeByTypeName(typeString);
 
-      if (type === null) {
-        fileContext.debug(`The '${typeName}' type is not present.`);
-      } else {
-        this.type = type; ///
+    if (type === null) {
+      fileContext.debug(`The '${typeString}' type is not present.`);
+    } else {
+      this.type = type; ///
 
-        typeVerified = true;
-      }
+      typeVerified = true;
+    }
 
-      if (typeVerified) {
-        fileContext.debug(`...verified the '${typeName}' type.`);
-      }
+    if (typeVerified) {
+      fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerified;
@@ -215,9 +201,8 @@ export default domAssigned(class Variable {
           node = variableNode,
           name = variableName,  ///
           type = typeFromJSON(json, fileContext),
-          provisional = null,
           propertyRelations = [],
-          variable = new Variable(string, node, name, type, provisional, propertyRelations);
+          variable = new Variable(string, node, name, type, propertyRelations);
 
     return variable;
   }
@@ -228,9 +213,10 @@ export default domAssigned(class Variable {
     const termVariableNode = termVariableNodeQuery(termNode);
 
     if (termVariableNode !== null) {
-      const variableNode = termVariableNode;  ///
+      const variableNode = termVariableNode,  ///
+            type = null;
 
-      variable = variableFromVariableNode(variableNode, context);
+      variable = variableFromVariableNodeAndType(variableNode, type, context);
     }
 
     return variable;
@@ -240,7 +226,9 @@ export default domAssigned(class Variable {
     let variable = null;
 
     if (variableNode !== null) {
-      variable = variableFromVariableNode(variableNode, context);
+      const type = null;
+
+      variable = variableFromVariableNodeAndType(variableNode, type, context);
     }
 
     return variable;
@@ -250,9 +238,7 @@ export default domAssigned(class Variable {
     let variable = null;
 
     if (variableNode !== null) {
-      variable = variableFromVariableNode(variableNode, context);
-
-      variable.setType(type);
+      variable = variableFromVariableNodeAndType(variableNode, type, context);
     }
 
     return variable;
@@ -264,13 +250,8 @@ export default domAssigned(class Variable {
           variableNode = variableDeclarationVariableNode, ///
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
-          variable = variableFromVariableNode(variableNode, context),
           type = Type.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
-          provisional = provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext);
-
-    variable.setType(type);
-
-    variable.setProvisional(provisional);
+          variable = variableFromVariableNodeAndType(variableNode, type, context);
 
     return variable;
   }
@@ -280,8 +261,7 @@ export default domAssigned(class Variable {
 
     const node = variable.getNode(),
           name = variable.getName(),
-          type = variable.getType(),
-          provisional = variable.isProvisional();
+          type = variable.getType();
 
     propertyRelations = variable.getPropertyRelations();
 
@@ -292,22 +272,20 @@ export default domAssigned(class Variable {
 
     const string = stringFromNameAndPropertyRelations(name, propertyRelations);
 
-    variable = new Variable(string, node, name, type, provisional, propertyRelations);
+    variable = new Variable(string, node, name, type, propertyRelations);
 
     return variable;
   }
 });
 
-function variableFromVariableNode(variableNode, context) {
+function variableFromVariableNodeAndType(variableNode, type, context) {
   const { Variable } = dom,
         node = variableNode,  ///
         variableName = variableNameFromVariableNode(variableNode),
         string = context.nodeAsString(node),
         name = variableName,  ///
-        type = null,
-        provisional = null,
         propertyRelations = [],
-        variable = new Variable(string, node, name, type, provisional, propertyRelations);
+        variable = new Variable(string, node, name, type, propertyRelations);
 
   return variable;
 }
@@ -324,18 +302,3 @@ function stringFromNameAndPropertyRelations(name, propertyRelations) {
 
   return string;
 }
-
-function provisionalFromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-  let provisional = false;
-
-  const lastSecondaryKeywordTerminalNode = lastSecondaryKeywordTerminalNodeQuery(variableDeclarationNode);
-
-  if (lastSecondaryKeywordTerminalNode !== null) {
-    const content = lastSecondaryKeywordTerminalNode.getContent(),
-          contentProvisionally = (content === PROVISIONALLY);
-
-    provisional = contentProvisionally; ///
-  }
-
-  return provisional;
-}

package/src/equivalence.js

@@ -217,9 +217,9 @@ export default class Equivalence {
     }, null);
 
     const type = this.getType(),
-          typeName = type.getName();
+          typeString = type.getString();
 
-    string = `${string}:${typeName}`;
+    string = `${string}:${typeString}`;
 
     return string;
   }

package/src/node/assertion/contained.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class ContainedAssertionNode extends Node {}

package/src/node/assertion/defined.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class DefinedAssertionNode extends Node {}

package/src/node/assertion/property.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class PropertyAssertionNode extends Node {}

package/src/node/assertion/satisfies.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class SatisfiesAssertionNode extends Node {}

package/src/node/assertion/subproof.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class SubproofAssertionNode extends Node {}

package/src/node/assertion/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class TypeAssertionNode extends Node {}

package/src/node/axiom.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class AxiomNode extends Node {}

package/src/node/combinator.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class CombinatorNode extends Node {}

package/src/node/conclusion.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ConclusionNode extends Node {}

package/src/node/conjecture.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ConjectureNode extends Node {}

package/src/node/constructor.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ConstructorNode extends Node {}

package/src/node/declaration/combinator.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class ContainedDeclarationNode extends Node {}

package/src/node/declaration/complexType.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class ComplexTypeDeclarationNode extends Node {}

package/src/node/declaration/constructor.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class ConstructorDeclarationNode extends Node {}

package/src/node/declaration/metavariable.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class MetavariableDeclarationNode extends Node {}

package/src/node/declaration/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class TypeDeclarationNode extends Node {}

package/src/node/declaration/variable.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../../node";
+
+export default class VariableDeclarationNode extends Node {}

package/src/node/declaration.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class DeclarationNode extends Node {}

package/src/node/deduction.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class DeductionNode extends Node {}