occam-verify-cli 1.0.320 → 1.0.325

package/src/dom/type.js

@@ -13,19 +13,15 @@ import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, pro
 const { push, first } = arrayUtilities;
 
 class Type {
-  constructor(context, string, name, superTypes, properties, provisional) {
-    this.context = context;
+  constructor(string, name, prefixName, superTypes, properties, provisional) {
     this.string = string;
     this.name = name;
+    this.prefixName = prefixName;
     this.superTypes = superTypes;
     this.properties = properties;
     this.provisional = provisional;
   }
 
-  getContext() {
-    return this.context;
-  }
-
   getString() {
     return this.string;
   }
@@ -34,6 +30,10 @@ class Type {
     return this.name;
   }
 
+  getPrefixName() {
+    return this.prefixName;
+  }
+
   getSuperTypes() {
     return this.superTypes;
   }
@@ -76,6 +76,10 @@ class Type {
     this.name = name;
   }
 
+  setPrefixName(prefixName) {
+    this.prefixName = prefixName;
+  }
+
   setSuperTypes(superTypes) {
     this.superTypes = superTypes;
   }
@@ -88,40 +92,39 @@ class Type {
     this.provisional = provisional;
   }
 
-  getPrefix() {
-    let prefix = null;
-
-    if (this.context !== null) {
-      const typePrefix = this.context.getTypePrefix();
+  replaceSuperType(oldSuperType, newSuperType) {
+    const index = this.superTypes.indexOf(oldSuperType),
+          start = index,
+          deleteCount = 1;
 
-      prefix = typePrefix;  ///
-    }
-
-    return prefix;
+    this.superTypes.splice(start, deleteCount, newSuperType);
   }
 
-  isInternal(context) {
-    let internal,
-        fileContext,
-        releaseContext;
+  isPrefixed() {
+    const prefixed = (this.prefixName !== null);
 
-    if (this.context !== null) {
-      fileContext = this.context; ///
+    return prefixed;
+  }
 
-      releaseContext = fileContext.getReleaseContext();
+  getPrefixedName() {
+    let prefixedName = null;
 
-      const internalReleaseContext = releaseContext; ///
+    const prefixed = this.isPrefixed();
 
-      fileContext = context;  ///
+    if (prefixed) {
+      prefixedName = `${this.prefixName}${this.name}`;
+    }
 
-      releaseContext = fileContext.getReleaseContext();
+    return prefixedName;
+  }
 
-      internal = (internalReleaseContext === releaseContext); ///
-    } else {
-      internal = false;
-    }
+  getNominalTypeName() {
+    const prefixed = this.isPrefixed(),
+          nominalTypeName = prefixed ?
+                             `${this.prefixName}${this.name}` :
+                                this.name;
 
-    return internal;
+    return nominalTypeName;
   }
 
   isBasic() {
@@ -219,22 +222,9 @@ class Type {
     return equalToOrSuperTypeOf;
   }
 
-  matchTypeName(typeName, prefixed, context) {
-    let typeNameMatches;
-
-    const naked = !prefixed,
-          internal = this.isInternal(context);
-
-    if (naked || internal) {
-      typeNameMatches = (this.name === typeName);
-    } else {
-      const prefix = this.getPrefix(),
-            name = (prefix !== null) ?
-                    `${prefix}${this.name}` :
-                       this.name;
-
-      typeNameMatches = (name === typeName);
-    }
+  matchTypeName(typeName) {
+    const name = this.getName(),
+          typeNameMatches = (name === typeName);
 
     return typeNameMatches;
   }
@@ -253,6 +243,42 @@ class Type {
     return provisionalMatches;
   }
 
+  matchPrefixedTypeName(prefixedTypeName) {
+    let prefixedTypeNameMatches = false;
+
+    const prefixed = this.isPrefixed();
+
+    if (prefixed) {
+      const prefixedName = this.getPrefixedName();
+
+      prefixedTypeNameMatches = (prefixedTypeName === prefixedName);
+    }
+
+    return prefixedTypeNameMatches;
+  }
+
+  matchNominalTypeName(nominalTypeName) {
+    let nominalTypeNameMatches = false;
+
+    if (!nominalTypeNameMatches) {
+      const name = this.getName();
+
+      nominalTypeNameMatches = (nominalTypeName === name);
+    }
+
+    if (!nominalTypeNameMatches) {
+      const prefixed = this.isPrefixed();
+
+      if (prefixed) {
+        const prefixedName = this.getPrefixedName();
+
+        nominalTypeNameMatches = (nominalTypeName === prefixedName);
+      }
+    }
+
+    return nominalTypeNameMatches;
+  }
+
   toJSON() {
     const propertiesJSON = propertiesToPropertiesJSON(this.properties),
           superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
@@ -260,8 +286,10 @@ class Type {
           properties = propertiesJSON,  ///
           superTypes = superTypesJSON,  ///
           name = this.name,
+          prefixName = this.prefixName,
           json = {
             name,
+            prefixName,
             superTypes,
             properties,
             provisional
@@ -273,13 +301,13 @@ class Type {
   static name = "Type";
 
   static fromJSON(json, context) {
-    const { name, provisional } = json,
+    const { name, prefixName, provisional } = json,
           properties = propertiesFromJSON(json, context),
           superTypes = superTypesFromJSON(json, context),
           typeName = name,  ///
           typePrefixName = null,
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(context, string, name, superTypes, properties, provisional);
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -290,6 +318,15 @@ class Type {
     return type;
   }
 
+  static fromSuperTypeNode(superTypeNode, context) {
+    context = null; ///
+
+    const typeNode = superTypeNode, ///
+          type = typeFromTypeNode(typeNode, context);
+
+    return type;
+  }
+
   static fromTypeAssertionNode(typeAssertionNode, context) {
     const typeNode = typeAssertionNode.getTypeNode(),
           type = typeFromTypeNode(typeNode, context);
@@ -298,18 +335,18 @@ class Type {
   }
 
   static fromTypeAndProvisional(type, provisional) {
-    const context = type.getContext(),
-          name = type.getName(),
+    const name = type.getName(),
+          prefixName = type.getPrefixName(),
           superType = type, ///
           typeName = name,  ///
-          typePrefixName = null,
+          typePrefixName = prefixName,  ///
           superTypes = [
             superType
           ],
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
           properties = type.getProperties();
 
-    type = new Type(context, string, name, superTypes, properties, provisional);  ///
+    type = new Type(string, name, prefixName, superTypes, properties, provisional);  ///
 
     return type;
   }
@@ -327,9 +364,10 @@ class Type {
           typeName = simpleTypeDeclarationNode.getTypeName(),
           typePrefixName = simpleTypeDeclarationNode.getTypePrefixName(),
           name = typeName,  ///
+          prefixName = typePrefixName,  ///
           superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(context, string, name, superTypes, properties, provisional);
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -339,10 +377,11 @@ class Type {
           typeName = complexTypeDeclarationNode.getTypeName(),
           typePrefixName = complexTypeDeclarationNode.getTypePrefixName(),
           name = typeName,  ///
+          prefixName = typePrefixName,  ///
           superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           string = stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes),
-          type = new Type(context, string, name, superTypes, properties, provisional);
+          type = new Type(string, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }
@@ -371,10 +410,17 @@ export default domAssigned(Type);
 function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, context);
+          const superType = Type.fromSuperTypeNode(superTypeNode, context);
 
           return superType;
-        });
+        }),
+        superTypesLength = superTypes.length;
+
+  if (superTypesLength === 0) {
+    const superType = objectType; ///
+
+    superTypes.push(superType);
+  }
 
   return superTypes;
 }
@@ -382,10 +428,17 @@ function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, cont
 function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
-          const superType = Type.fromTypeNode(superTypeNode, context);
+          const superType = Type.fromSuperTypeNode(superTypeNode, context);
 
           return superType;
-        });
+        }),
+        superTypesLength = superTypes.length;
+
+  if (superTypesLength === 0) {
+    const superType = objectType; ///
+
+    superTypes.push(superType);
+  }
 
   return superTypes;
 }
@@ -404,13 +457,13 @@ function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, co
 
 class ObjectType extends Type {
   static fromNothing() {
-    const context = null,
-          name = OBJECT_TYPE_NAME,
+    const name = OBJECT_TYPE_NAME,
           string = name,  ///
+          prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          objectType = new ObjectType(context, string, name, superTypes, properties, provisional);
+          objectType = new ObjectType(string, name, prefixName, superTypes, properties, provisional);
 
     return objectType;
   }

package/src/dom/variable.js

@@ -92,12 +92,12 @@ export default domAssigned(class Variable {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeName = this.tyupe.getName(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' type...`);
 
-    const type = context.findTypeByTypeName(typeName);
+    const prefixedTypeName = this.type.getPrefixedName(),
+          type = context.findTypeByPrefixedTypeName(prefixedTypeName);
 
     if (type === null) {
       context.debug(`The '${typeString}' type is not present.`);

package/src/node/declaration/complexType.js

@@ -77,6 +77,13 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return typePrefixName;
   }
 
+  getNominalTypeName() {
+    const typeNode = this.getTypeNode(),
+          nominalTypeName = typeNode.getNominalTypeName();
+
+    return nominalTypeName;
+  }
+
   getPropertyDeclarationNodes() {
     const ruleName = PROPERTY_DECLARATION_RULE_NAME,
           propertyDeclarationNodes = this.getNodesByRuleName(ruleName);

package/src/node/declaration/simpleType.js

@@ -82,6 +82,13 @@ export default class SimpleTypeDeclarationNode extends NonTerminalNode {
     return superTypeNodes;
   }
 
+  getNominalTypeName() {
+    const typeNode = this.getTypeNode(),
+          nominalTypeName = typeNode.getNominalTypeName();
+
+    return nominalTypeName;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SimpleTypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }
 

package/src/node/type.js

@@ -53,5 +53,22 @@ export default class TypeNode extends NonTerminalNode {
     return typePrefixName;
   }
 
+  getNominalTypeName() {
+    let nominalTypeName;
+
+    const prefixed = this.isPrefixed(),
+          typeName = this.getTypeName();
+
+    if (prefixed) {
+      const typePrefixName = this.getTypePrefixName();
+
+      nominalTypeName = `${typePrefixName}${typeName}`;
+    } else {
+      nominalTypeName = typeName;  ///
+    }
+
+    return nominalTypeName;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/unifier/metavariable.js

@@ -31,8 +31,8 @@ class MetavariableUnifier extends Unifier {
         const { Term } = dom,
               typeNode = generalTypeNode, ///
               termNode = specificTermNode, ///
-              typeName = typeNode.getTypeName(),
-              type = generalContext.findTypeByTypeName(typeName),
+              nominalTypeName = typeNode.getNominalTypeName(),
+              type = generalContext.findTypeByNominalTypeName(nominalTypeName),
               context = specificContext, ///
               term = Term.fromTermNode(termNode, context),
               termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);

package/src/unifier/statementWithCombinator.js

@@ -86,13 +86,13 @@ class StatementWithCombinatorUnifier extends Unifier {
         const { Term } = dom,
               typeNode = generalTypeNode, ///
               termNode = specificTermNode, ///
-              typeName = typeNode.getTypeName();
+              nominalTypeName = typeNode.getNominalTypeName();
 
         let context;
 
         context = generalContext; ///
 
-        const type = context.findTypeByTypeName(typeName);
+        const type = context.findTypeByNominalTypeName(nominalTypeName);
 
         context = specificContext;  ///
 

package/src/unifier/termWithConstructor.js

@@ -30,8 +30,8 @@ class TermWithConstructorUnifier extends Unifier {
 
         const { Term } = dom,
               typeNode = generalTypeNode, ///
-              typeName = typeNode.getTypeName(),
-              type = context.findTypeByTypeName(typeName);
+              nominalTypeName = typeNode.getNominalTypeName(),
+              type = context.findTypeByNominalTypeName(nominalTypeName);
 
         if (type !== null) {
           const termNode = specificTermNode, ///

package/src/utilities/json.js

@@ -20,10 +20,14 @@ export function typeFromJSON(json, context) {
   let { type } = json;
 
   if (type !== null) {
-    const { name } = type,
-          typeName = name;  ///
+    json = type;  ///
 
-    type = context.findTypeByTypeName(typeName);
+    const { name, prefixName } = json,
+          nominalTypeName = (prefixName !== null) ?
+                               `${prefixName}:${name}` :
+                                  name; ///
+
+    type = context.findTypeByNominalTypeName(nominalTypeName);
   }
 
   return type;
@@ -33,7 +37,9 @@ export function metaTypeFromJSON(json, context) {
   let { metaType } = json;
 
   if (metaType !== null) {
-    const { name } = metaType,
+    json = metaType;  ///
+
+    const { name } = json,
           metaTypeName = name;  ///
 
     metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
@@ -172,11 +178,11 @@ export function rulesFromJSON(json, context) {
   let { rules } = json;
 
   const { Rule } = dom,
-    rulesJSON = rules; ///
+        rulesJSON = rules; ///
 
   rules = rulesJSON.map((ruleJSON) => {
     const json = ruleJSON,  ///
-      rule = Rule.fromJSON(json, context);
+          rule = Rule.fromJSON(json, context);
 
     return rule;
   });
@@ -298,9 +304,11 @@ export function superTypesFromJSON(json, context) {
 
   const superTypes = superTypesJSON.map((superTypeJSON) => {
           const json = superTypeJSON,  ///
-                { name } = json,
-                superTypeName = name,  ///
-                superType = context.findTypeByTypeName(superTypeName);
+                { name, prefixName } = json,
+                nominalSuperTypeName = (prefixName !== null) ?
+                                          `${prefixName}:${name}` :
+                                            name, ///
+                superType = context.findTypeByNominalTypeName(nominalSuperTypeName);
 
           return superType;
         });
@@ -373,7 +381,7 @@ export function combinatorsFromJSON(json, context) {
 }
 
 export function typePrefixesFromJSON(json, context) {
-  let { typePrefixes = [] } = json;
+  let { typePrefixes } = json;
 
   const { TypePrefix } = dom,
         typePrefixesJSON = typePrefixes; ///

package/src/utilities/node.js

@@ -12,22 +12,16 @@ export function typeFromTypeNode(typeNode, context) {
   } else {
     const { Type } = dom,
           typeName = typeNode.getTypeName(),
-          typePrefixName = typeNode.getTypePrefixName();
-
-    let string;
-
-    string = typeName;  ///
-
-    if (typePrefixName !== null) {
-      string = `${typePrefixName}${string}`;
-    }
-
-    const name = typeName,  ///
+          typePrefixName = typeNode.getTypePrefixName(),
+          nominalTypeName = typeNode.getNominalTypeName(),
+          string = nominalTypeName,  ///
+          name = typeName,  ///
+          prefixName = typePrefixName,  ///
           superTypes = null,
           properties = null,
           provisional = null;
 
-    type = new Type(context, string, name, superTypes, properties, provisional);
+    type = new Type(string, name, prefixName, superTypes, properties, provisional);
   }
 
   return type;

package/src/verifier/combinator.js

@@ -54,8 +54,8 @@ class CombinatorVerifier extends Verifier {
       verify: (typeNode, context) => {
         let typeVerifies = false;
 
-        const typeName = typeNode.getTypeName(),
-              typePresent = context.isTypePresentByTypeName(typeName);
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
           typeVerifies = true;

package/src/verifier/constructor.js

@@ -70,15 +70,15 @@ class ConstructorVerifier extends Verifier {
       verify: (typeNode, context, verifyAhead) => {
         let typeVerifies;
 
-        const typeName = typeNode.getTypeName(),
-              typePresent = context.isTypePresentByTypeName(typeName);
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
           const verifiesAhead = verifyAhead();
 
           typeVerifies = verifiesAhead; ///
         } else {
-          const typeString = typeName;  ///
+          const typeString = nominalTypeName; ///
 
           context.debug(`The '${typeString}' type is not present.`);