occam-verify-cli 0.0.1264 → 0.0.1266

package/src/dom/type.js

@@ -1,13 +1,16 @@
 "use strict";
 
-import { nodeQuery } from "../utilities/query";
+import dom from "../dom";
+
 import { domAssigned } from "../dom";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { typeNameFromTypeNode } from "../utilities/name";
-import { superTypeFromJSON, superTypeToSuperTypeJSON } from "../utilities/json";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { superTypeFromJSON, superTypeToSuperTypeJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
-const typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
-      typeDeclarationSuperTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
+const typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type[0]"),
+      propertyDeclarationNodesQuery = nodesQuery("/complexTypeDeclaration/propertyDeclaration"),
+      typeDeclarationSuperTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type[1]");
 
 class Type {
   constructor(string, name, superType, properties) {
@@ -33,6 +36,22 @@ class Type {
     return this.properties;
   }
 
+  setString(string) {
+    this.string = string;
+  }
+
+  setName(name) {
+    this.name = name;
+  }
+
+  setSuperType(superType) {
+    this.superType = superType;
+  }
+
+  setProperties(properties) {
+    this.properties = properties;
+  }
+
   isEqualTo(type) {
     const equalTo = (this === type);
 
@@ -107,39 +126,6 @@ class Type {
     return typeNodeMatches;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared = false;
-
-    const typeString = this.string; ///
-
-    fileContext.trace(`Verifying the '${typeString}' type when declared...`);
-
-    const typePresent = fileContext.isTypePresentByTypeName(this.name);
-
-    if (typePresent) {
-      fileContext.debug(`The type '${typeString}' has already been declared.`);
-    } else {
-      const superTypeName = this.superType.getName(),
-            superType = fileContext.findTypeByTypeName(superTypeName);
-
-      if (superType === null) {
-        const superTypeString = this.superType.getString();
-
-        fileContext.debug(`The super-type '${superTypeString}' is not present.`);
-      } else {
-        this.superType = superType;
-
-        verifiedWhenDeclared = true;
-      }
-    }
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${typeString}' type when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
   toJSON() {
     const propertiesJSON = propertiesToPropertiesJSON(this.properties),
           superTypeJSON = superTypeToSuperTypeJSON(this.superType),
@@ -240,6 +226,34 @@ function superTypeFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   return superType;
 }
 
+function typeNameFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+  const typeDeclarationTypeNode = typeDeclarationTypeNodeQuery(complexTypeDeclarationNode),
+        typeNode = typeDeclarationTypeNode, ///
+        typeName = typeNameFromTypeNode(typeNode);
+
+  return typeName;
+}
+
+function superTypeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+  const typeDeclarationSuperTypeNode = typeDeclarationSuperTypeNodeQuery(complexTypeDeclarationNode),
+        superTypeNode = typeDeclarationSuperTypeNode, ///
+        superType = Type.fromTypeNode(superTypeNode);
+
+  return superType;
+}
+
+function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+  const propertyDeclarationNodes = propertyDeclarationNodesQuery(complexTypeDeclarationNode),
+        properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {
+          const { Property } = dom,
+                property = Property.fromPropertyDeclarationNode(propertyDeclarationNode, fileContext);
+
+          return property;
+        });
+
+  return properties;
+}
+
 class ObjectType extends Type {
   toJSON() {
     const superType = null,

package/src/dom/variable.js

@@ -119,7 +119,7 @@ export default domAssigned(class Variable {
       const type = fileContext.findTypeByTypeName(typeName);
 
       if (type === null) {
-        fileContext.debug(`The '${typeName}' type is missing.`);
+        fileContext.debug(`The '${typeName}' type is not present.`);
       } else {
         this.type = type; ///
 
@@ -134,38 +134,6 @@ export default domAssigned(class Variable {
     return typeVerified;
   }
 
-  verifyWhenDeclared(fileContext) {
-    let verifiedWhenDeclared;
-
-    const variableString = this.string; ///
-
-    fileContext.trace(`Verifying the '${variableString}' variable when declared...`);
-
-    const variableName = this.name, ///
-          variablePresent = fileContext.isVariablePresentByVariableName(variableName);
-
-    if (variablePresent) {
-      fileContext.debug(`The '${variableName}' variable has already been declared.`);
-    } else {
-      const metavariableName = this.name, ///
-            metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
-
-      if (metavariablePresent) {
-        fileContext.debug(`A '${metavariableName}' variable has already been declared.`);
-      } else {
-        const typeVerified = this.verifyType(fileContext);
-
-        verifiedWhenDeclared = typeVerified;  ///
-      }
-    }
-
-    if (verifiedWhenDeclared) {
-      fileContext.debug(`...verified the '${variableString}' variable when declared.`);
-    }
-
-    return verifiedWhenDeclared;
-  }
-
   unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnified = false;
 

package/src/index.js

@@ -15,6 +15,7 @@ import Equality from "./dom/equality";
 import MetaType from "./dom/metaType";
 import Subproof from "./dom/subproof";
 import Variable from "./dom/variable";
+import Property from "./dom/property";
 import Parameter from "./dom/parameter";
 import ProofStep from "./dom/proofStep";
 import Reference from "./dom/reference";

package/src/utilities/customGrammar.js

@@ -7,9 +7,8 @@ export function customGrammarFromNameAndEntries(name, entries) {
         statementBNF = entries.getStatementBNF(),
         typePattern = entries.getTypePattern(),
         symbolPattern = entries.getSymbolPattern(),
-        propertyPattern = entries.getPropertyPattern(),
         operatorPattern = entries.getOperatorPattern(),
-        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypePatternSymbolPatternPropertyPatternAndOperatorPattern(name, termBNF, statementBNF, typePattern, symbolPattern, propertyPattern, operatorPattern);
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, typePattern, symbolPattern, operatorPattern);
 
   return customGrammar;
 }

package/src/utilities/json.js

@@ -547,6 +547,18 @@ export function parametersToParametersJSON(parameters) {
   return parametersJSON;
 }
 
+export function propertiesToPropertiesJSON(properties) {
+  const propertiesJSON = properties.map((property) => {
+    const propertyJSON = property.toJSON();
+
+    property = propertyJSON;  ///
+
+    return property;
+  });
+
+  return propertiesJSON;
+}
+
 export function conjecturesToConjecturesJSON(conjectures) {
   const conjecturesJSON = conjectures.map((conjecture) => {
     const conjectureJSON = conjecture.toJSON();