occam-verify-cli 1.0.318 → 1.0.325

package/src/node/declaration/complexType.js

@@ -28,6 +28,13 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  isPrefixed() {
+    const typeNode = this.getTypeNode(),
+          prefixed = typeNode.isPrefixed();
+
+    return prefixed;
+  }
+
   getTypeName() {
     const typeNode = this.getTypeNode(),
           typeName = typeNode.getTypeName();
@@ -63,6 +70,20 @@ export default class ComplexTypeDeclarationNode extends NonTerminalNode {
     return superTypeNodes;
   }
 
+  getTypePrefixName() {
+    const typeNode = this.getTypeNode(),
+          typePrefixName = typeNode.getTypePrefixName();
+
+    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

@@ -28,6 +28,13 @@ export default class SimpleTypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  isPrefixed() {
+    const typeNode = this.getTypeNode(),
+          prefixed = typeNode.isPrefixed();
+
+    return prefixed;
+  }
+
   getTypeName() {
     let typeName = null;
 
@@ -54,6 +61,13 @@ export default class SimpleTypeDeclarationNode extends NonTerminalNode {
     return typesNode;
   }
 
+  getTypePrefixName() {
+    const typeNode = this.getTypeNode(),
+          typePrefixName = typeNode.getTypePrefixName();
+
+    return typePrefixName;
+  }
+
   getSuperTypeNodes() {
     let superTypeNodes = [];
 
@@ -68,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

@@ -3,11 +3,21 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class TypeNode extends NonTerminalNode {
+  isPrefixed() {
+    const multiplicity = this.getMultiplicity(),
+          prefixed = (multiplicity > 1);
+
+    return prefixed;
+  }
+
   getTypeName() {
     let typeName;
 
+    const prefixed = this.isPrefixed(),
+          nameIndex = prefixed ? 2 : 0;
+
     this.someChildNode((childNode, index) => {
-      if (index === 0) {
+      if (index === nameIndex) {
         const typeTerminalNode = childNode, ///
               content = typeTerminalNode.getContent();
 
@@ -23,19 +33,42 @@ export default class TypeNode extends NonTerminalNode {
   getTypePrefixName() {
     let typePrefixName = null;
 
-    this.someChildNode((childNode, index) => {
-      if (index === 2) {
-        const typeTerminalNode = childNode, ///
-              content = typeTerminalNode.getContent();
+    const prefixed = this.isPrefixed();
 
-        typePrefixName = content; ///
+    if (prefixed) {
+      const prefixIndex = 0;
 
-        return true;
-      }
-    });
+      this.someChildNode((childNode, index) => {
+        if (index === prefixIndex) {
+          const typeTerminalNode = childNode, ///
+                content = typeTerminalNode.getContent();
+
+          typePrefixName = content; ///
+
+          return true;
+        }
+      });
+    }
 
     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

@@ -4,7 +4,7 @@ import dom from "../dom";
 
 import { objectType } from "../dom/type";
 
-export function typeFromTypeNode(typeNode) {
+export function typeFromTypeNode(typeNode, context) {
   let type;
 
   if (typeNode === null) {
@@ -12,13 +12,16 @@ export function typeFromTypeNode(typeNode) {
   } else {
     const { Type } = dom,
           typeName = typeNode.getTypeName(),
+          typePrefixName = typeNode.getTypePrefixName(),
+          nominalTypeName = typeNode.getNominalTypeName(),
+          string = nominalTypeName,  ///
           name = typeName,  ///
-          string = name,  ///
+          prefixName = typePrefixName,  ///
           superTypes = null,
           properties = null,
           provisional = null;
 
-    type = new Type(string, name, superTypes, properties, provisional);
+    type = new Type(string, name, prefixName, superTypes, properties, provisional);
   }
 
   return type;

package/src/utilities/type.js

@@ -2,11 +2,18 @@
 
 import { objectType } from "../dom/type";
 
-export function stringFromTypeNameNameAndSuperTypes(typeName, superTypes) {
-  const superTypesString = superTypesStringFromSuperTypes(superTypes),
-        string = (superTypesString !== null) ?
-                   `'${typeName}':${superTypesString}` :
-                     typeName; ///
+export function stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
+  let string;
+
+  string = (typePrefixName !== null) ?
+             `${typePrefixName}${typeName}`:
+               typeName;
+
+  const superTypesString = superTypesStringFromSuperTypes(superTypes);
+
+  if (superTypesString !== null) {
+    string = `${string}:${superTypesString}`;
+  }
 
   return string;
 }

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.`);