occam-furtle 3.0.305 → 3.0.310

package/src/element/binding.js

@@ -37,10 +37,12 @@ export default define(class Binding extends Element {
 
     context.trace(`Comparing the '${termString}' term against the '${bindingString}' binding...`);
 
-    const termType = term.getType();
+    const termType = term.getType(),
+          typeEqualToTermType = this.type.isEqualTo(termType);
 
-    if (this.type !== termType) {
-      const message = `The '${termString}' term's '${termType}' type is not equal to the '${bindingString}' binding's '${this.type}' type.`,
+    if (!typeEqualToTermType) {
+      const typeString = this.type.getString(),
+            message = `The '${termString}' term's '${termType}' type is not equal to the '${bindingString}' binding's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/every.js

@@ -7,7 +7,7 @@ import Exception from "../exception";
 
 import { define } from "../elements";
 import { valueFromNode, valueFromBoolean } from "../utilities/value";
-import { BOOLEAN_TYPE, NOMINAL_VALUES_TYPE } from "../types";
+import { LIST_TYPE_NAME, BOOLEAN_TYPE_NAME } from "../typeNames";
 
 const { asyncEvery } = asynchronousUtilities;
 
@@ -39,11 +39,12 @@ export default define(class Every extends Element {
 
     value = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeListType = valueType.isListType();
 
-    if (valueType !== NOMINAL_VALUES_TYPE) {
+    if (valueTypeListType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUES_TYPE}'.`,
+            message = `The '${valueString}' value's '${valueType}' type should be '${LIST_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -61,11 +62,12 @@ export default define(class Every extends Element {
 
             value = await this.anonymousProcedure.call(values, context);
 
-            const valueType = value.getType();
+            const valueType = value.getType(),
+                  valueTypeBooleanType = valueType.isBooleanType();
 
-            if (valueType !== BOOLEAN_TYPE) {
+            if (!valueTypeBooleanType) {
               const termString = term.getString(),
-                    message = `The '${termString}' term's type is '${termType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+                    message = `The '${termString}' term's type is '${termType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
                     exception = Exception.fromMessage(message);
 
               throw exception;

package/src/element/nodeQuery.js

@@ -6,7 +6,7 @@ import { arrayUtilities } from "necessary";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { NOMINAL_VALUE_TYPE } from "../types";
+import { NOMINAL_VALUE_TYPE_NAME } from "../typeNames";
 import { valueFromNodeAndNominalValue } from "../utilities/value";
 
 const { first } = arrayUtilities;
@@ -43,11 +43,12 @@ export default define(class NodeQuery extends Element {
 
     value = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeNominalValueType = valueType.isNominalValueType();
 
-    if (valueType !== NOMINAL_VALUE_TYPE) {
+    if (!valueTypeNominalValueType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE}'.`,
+            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/nodesQuery.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { NOMINAL_VALUE_TYPE } from "../types";
+import { NOMINAL_VALUE_TYPE_NAME } from "../typeNames";
 import { valueFromNodesAndNominalValue } from "../utilities/value";
 
 export default define(class NodesQuery extends Element {
@@ -40,11 +40,12 @@ export default define(class NodesQuery extends Element {
 
     value = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeNominalValueType = valueType.isNominalValueType();
 
-    if (valueType !== NOMINAL_VALUE_TYPE) {
+    if (!valueTypeNominalValueType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE}'.`,
+            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/parameter.js

@@ -28,10 +28,12 @@ export default define(class Parameter extends Element {
 
     context.trace(`Comparing the '${valueString}' value against the '${parameterString}' parameter...`);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          typeEqualToValueType = this.type.isEqualTo(valueType);
 
-    if (this.type !== valueType) {
-      const message = `The '${valueString}' value's '${valueType}' type is not equal to the '${parameterString}' parameter's '${this.type}' type.`,
+    if (!typeEqualToValueType) {
+      const typeString = ths.type.getString(),
+            message = `The '${valueString}' value's '${valueType}' type is not equal to the '${parameterString}' parameter's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/primitive.js

@@ -6,7 +6,7 @@ import { arrayUtilities } from "necessary";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE, NOMINAL_VALUE_TYPE, NOMINAL_VALUES_TYPE } from "../types";
+import { LIST_TYPE_NAME, STRING_TYPE_NAME, NUMBER_TYPE_NAME, BOOLEAN_TYPE_NAME, NOMINAL_VALUE_TYPE_NAME } from "../typeNames";
 
 const { match } = arrayUtilities;
 
@@ -37,13 +37,33 @@ export default define(class Primitive extends Element {
   isEqualTo(primitive) {
     let equalTo = false;
 
-    const type = primitive.getType();
+    const primitiveType = primitive.getType(),
+          typeEqualToPrimitiveType = this.type.isEqualTo(primitiveType);
 
-    if (this.type === type) {
-      const value = primitive.getValue();
+    if (typeEqualToPrimitiveType) {
+      const value = primitive.getValue(),
+            typeName = this.type.getName();
 
-      switch (type) {
-        case STRING_TYPE: {
+      switch (typeName) {
+        case LIST_TYPE_NAME: {
+          const listA = this.value, ///
+                listB = value,  ///
+                matches = match(listA, listB, (valueA, valueB) => {
+                  const matches = valueA.isEqualTo(valueB);
+
+                  if (matches) {
+                    return true;
+                  }
+                });
+
+          if (matches) {
+            equalTo = true;
+          }
+
+          break;
+        }
+
+        case STRING_TYPE_NAME: {
           const stringLiteralA = this.value, ///
                 stringLiteralB = value;  ///
 
@@ -54,7 +74,7 @@ export default define(class Primitive extends Element {
           break;
         }
 
-        case NUMBER_TYPE: {
+        case NUMBER_TYPE_NAME: {
           const numberA = this.value, ///
                 numberB = value;  ///
 
@@ -65,7 +85,7 @@ export default define(class Primitive extends Element {
           break;
         }
 
-        case BOOLEAN_TYPE: {
+        case BOOLEAN_TYPE_NAME: {
           const booleanA = this.value, ///
                 booleanB = value;  ///
 
@@ -76,7 +96,7 @@ export default define(class Primitive extends Element {
           break;
         }
 
-        case NOMINAL_VALUE_TYPE: {
+        case NOMINAL_VALUE_TYPE_NAME: {
           const nominalValueA = this.value, ///
                 nomimalValueB = value,  ///
                 matches = nominalValueA.match(nomimalValueB);
@@ -87,30 +107,40 @@ export default define(class Primitive extends Element {
 
           break;
         }
+      }
+    }
 
-        case NOMINAL_VALUES_TYPE: {
-          const nominalValuesA = this.value, ///
-                nominalValuesB = value,  ///
-                matches = match(nominalValuesA, nominalValuesB, (nominalValueA, nomimalValueB) => {
-                  const matches = nominalValueA.match(nomimalValueB);
+    return equalTo;
+  }
 
-                  if (matches) {
-                    return true;
-                  }
-                });
+  static name = "Primitive";
 
-          if (matches) {
-            equalTo = true;
-          }
+  static fromPrimitiveValueAndType(primitiveValue, type, context) {
+    const value = primitiveValue, ///
+          typeName = type.getName();
 
-          break;
-        }
+    let string;
 
+    switch (typeName) {
+      case NOMINAL_VALUE_TYPE_NAME: {
+        const nominalValue = value;  ///
+
+        string = nominalValue.getString();
+
+        break;
+      }
+
+      default: {
+        string = `${value}`;
+
+        break;
       }
     }
 
-    return equalTo;
-  }
+    const node = null,
+          breakPoint = null,
+          primitive = new Primitive(context, string, node, breakPoint, type, value);
 
-  static name = "Primitive";
+    return primitive;
+  }
 });

package/src/element/procedure/anonymous.js

@@ -37,11 +37,13 @@ export default define(class AnonymousProcedure extends Element {
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context),
           value = await this.returnBlock.evaluate(variables, context),
-          valueType = value.getType();
+          valueType = value.getType(),
+          typeEqualToValueType = this.type.isEqualTo(valueType);
 
-    if (this.type !== valueType) {
+    if (!typeEqualToValueType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type is not equal to the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type.`,
+            typeString = this.type.getString(),
+            message = `The '${valueString}' value's '${valueType}' type is not equal to the '${anonymousProcedureString}' anonymous procedure's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/procedure.js

@@ -5,7 +5,6 @@ import { Element } from "occam-languages";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { BOOLEAN_TYPE } from "../types";
 import { valuesFromNominalValues } from "../utilities/values";
 import { variablesFromValuesAndParameters } from "../utilities/parameters";
 
@@ -35,15 +34,10 @@ export default define(class Procedure extends Element {
     return this.returnBlock;
   }
 
-  isBoolean() {
-    const typeBooleanType = (this.type === BOOLEAN_TYPE),
-          boolean = typeBooleanType;  ///
-
-    return boolean;
-  }
-
   getName() { return this.label.getName(); }
 
+  isBooleanType() { return this.type.isBooleanType(); }
+
   getReturnStatement() { return this.returnBlock.getReturnStatement(); }
 
   compareProcedureName(procedureName) { return this.label.compareProcedureName(procedureName); }
@@ -59,11 +53,13 @@ export default define(class Procedure extends Element {
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context),
           value = await this.returnBlock.evaluate(variables, context),
-          valueType = value.getType();
+          valueType = value.getType(),
+          typeEqualToValueType = this.type.isEqualTo(valueType);
 
-    if (this.type !== valueType) {
+    if (!typeEqualToValueType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type is not equal to the '${procedureString}' procedure's '${this.type}' type.`,
+            typeString = this.type.getString(),
+            message = `The '${valueString}' value's '${typeString}' type is not equal to the '${procedureString}' procedure's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -83,7 +79,7 @@ export default define(class Procedure extends Element {
 
     context.trace(`Calling the '${procedureString}' procedure nominally...`);
 
-    const values = valuesFromNominalValues(nominalValues),
+    const values = valuesFromNominalValues(nominalValues, context),
           term = await this.call(values, context);
 
     context.debug(`...called the '${procedureString}' procedure nominally.`);

package/src/element/reduce.js

@@ -6,8 +6,8 @@ import elements from "../elements";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { NOMINAL_VALUES_TYPE } from "../types";
 import { valueFromNominalValue } from "../utilities/value";
+import { LIST_TYPE_NAME } from "../typeNames";
 
 const { asyncReduce } = asynchronousUtilities;
 
@@ -43,11 +43,12 @@ export default define(class Reduce extends Element {
 
     value = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeListType = valueType.isListType();
 
-    if (valueType !== NOMINAL_VALUES_TYPE) {
+    if (!valueTypeListType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUES_TYPE}'.`,
+            message = `The '${valueString}' value's '${valueType}' type should be '${LIST_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -66,7 +67,7 @@ export default define(class Reduce extends Element {
 
       const values = Values.fromValue(value, context);
 
-      value = valueFromNominalValue(nominalValue, context);
+      value = valueFromNominalValue(nominalValue);
 
       values.addValue(value);
 

package/src/element/some.js

@@ -6,7 +6,7 @@ import elements from "../elements";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { BOOLEAN_TYPE, NOMINAL_VALUES_TYPE } from "../types";
+import { LIST_TYPE_NAME, BOOLEAN_TYPE_NAME } from "../typeNames";
 import { valueFromBoolean, valueFromNominalValue } from "../utilities/value";
 
 const { asyncSome } = asynchronousUtilities;
@@ -38,11 +38,12 @@ export default define(class Some extends Element {
 
     value = this.variable.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeListType = valueType.isListType();
 
-    if (valueType !== NOMINAL_VALUES_TYPE) {
+    if (!valueTypeListType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUES_TYPE}'.`,
+            message = `The '${valueString}' value's '${valueType}' type should be '${LIST_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
@@ -60,11 +61,12 @@ export default define(class Some extends Element {
 
             value = await this.anonymousProcedure.call(values, context);
 
-            const valueType = value.getType();
+            const valueType = value.getType(),
+                  valueTypeBooleanType = valueType.isBooleanType();
 
-            if (valueType !== BOOLEAN_TYPE) {
+            if (!valueTypeBooleanType) {
               const valueString = value.getString(),
-                    message = `The '${valueString}' value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+                    message = `The '${valueString}' value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
                     exception = Exception.fromMessage(message);
 
               throw exception;

package/src/element/term/comparison.js

@@ -38,12 +38,15 @@ export default define(class ComparisonTerm extends Element {
     const leftValue = this.leftTerm.evaluate(context),
           rightValue = this.rightTerm.evaluate(context),
           leftValueType = leftValue.getType(),
-          rightValueType = rightValue.getType();
+          rightValueType = rightValue.getType(),
+          leftValueTypeEqualToRightValueType = leftValueType.isEqualTo(rightValueType);
 
-    if (leftValueType !== rightValueType) {
+    if (!leftValueTypeEqualToRightValueType) {
       const leftValueString = leftValue.getString(),
             rightValueString = rightValue.getString(),
-            message = `The '${leftValueString}' left term's type is '${leftValueType}' whereas the '${rightValueString}' right term's type is '${rightTermType}'.`,
+            leftValueTypeString = leftValueType.getString(),
+            rightValueTypeString = rightValueType.getString(),
+            message = `The '${leftValueString}' left term's type is '${leftValueTypeString}' whereas the '${rightValueString}' right term's type is '${rightValueTypeString}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/term/logical.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import Exception from "../../exception";
 
 import { define } from "../../elements";
-import { BOOLEAN_TYPE } from "../../types";
+import { BOOLEAN_TYPE_NAME } from "../../typeNames";
 import { valueFromBoolean } from "../../utilities/value";
 
 export default define(class LogicalTerm extends Element {
@@ -44,19 +44,21 @@ export default define(class LogicalTerm extends Element {
     const leftValue = this.leftTerm.evaluate(context),
           rightValue = this.rightTerm.evaluate(context),
           leftValueType = leftValue.getType(),
-          rightValueType = rightValue.getType();
+          rightValueType = rightValue.getType(),
+          leftValueTypeBooleanType = leftValueType.isBooleanType(),
+          rightValueTypeBooleanType = rightValueType.isBooleanType();
 
-    if (leftValueType !== BOOLEAN_TYPE) {
+    if (!leftValueTypeBooleanType) {
       const leftValueString = leftValue.getString(),
-            message = `The '${leftValueString}' left term's type is '${leftValueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            message = `The '${leftValueString}' left term's type is '${leftValueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;
     }
 
-    if (rightValueType !== BOOLEAN_TYPE) {
+    if (!rightValueTypeBooleanType) {
       const rightValueString = rightValue.getString(),
-            message = `The '${rightValueString}' right term's type is '${rightValueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            message = `The '${rightValueString}' right term's type is '${rightValueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/term/negated.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import Exception from "../../exception";
 
 import { define } from "../../elements";
-import { BOOLEAN_TYPE } from "../../types";
+import { BOOLEAN_TYPE_NAME } from "../../typeNames";
 import { valueFromBoolean } from "../../utilities/value";
 
 export default define(class NegatedTerm extends Element {
@@ -33,11 +33,12 @@ export default define(class NegatedTerm extends Element {
 
     value = this.term.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeBooleanType = valueType.isBooleanType();
 
-    if (valueType !== BOOLEAN_TYPE) {
+    if (!valueTypeBooleanType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' left value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            message = `The '${valueString}' left value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/term.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { BOOLEAN_TYPE } from "../types";
+import { BOOLEAN_TYPE_NAME } from "../typeNames";
 
 export default define(class Term extends Element {
   constructor(context, string, node, breakPoint, variable, primitive, negatedTerm, logicalTerm, bracketedTerm, comparisonTerm) {
@@ -71,7 +71,8 @@ export default define(class Term extends Element {
 
   isBoolean() {
     const type = this.getType(),
-          boolean = (type === BOOLEAN_TYPE);
+          booleanType = type.isBooleanType(),
+          boolean = booleanType;  ///
 
     return boolean;
   }

package/src/element/ternary.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import Exception from "../exception";
 
 import { define } from "../elements";
-import { BOOLEAN_TYPE } from "../types";
+import { BOOLEAN_TYPE_NAME } from "../typeNames";
 
 export default define(class Ternary extends Element {
   constructor(context, string, node, breakPoint, term, ifExpression, elseExpression) {
@@ -37,11 +37,12 @@ export default define(class Ternary extends Element {
 
     value = this.term.evaluate(context);
 
-    const valueType = value.getType();
+    const valueType = value.getType(),
+          valueTypeBooleanType = valueType.isBooleanType();
 
-    if (valueType !== BOOLEAN_TYPE) {
+    if (!valueTypeBooleanType) {
       const valueString = value.getString(),
-            message = `The '${valueString}' value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            message = `The '${valueString}' value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
       throw exception;

package/src/element/type.js

@@ -0,0 +1,128 @@
+"use strict";
+
+import { Element } from "occam-languages";
+
+import { define } from "../elements";
+
+import { typeStringFromTypeNameAndArgumentTypeName } from "../utilities/string";
+import { LIST_TYPE_NAME, STRING_TYPE_NAME, NUMBER_TYPE_NAME, BOOLEAN_TYPE_NAME, NOMINAL_VALUE_TYPE_NAME } from "../typeNames";
+
+export default define(class Type extends Element {
+  constructor(context, string, node, breakPoint, name, argumentType) {
+    super(context, string, node, breakPoint);
+
+    this.name = name;
+    this.argumentType = argumentType;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getArgumentType() {
+    return this.argumentType;
+  }
+
+  isListType() {
+    const listType = (this.name === LIST_TYPE_NAME);
+
+    return listType;
+  }
+
+  isStringType() {
+    const booleanType = (this.name === STRING_TYPE_NAME);
+
+    return booleanType;
+  }
+
+  isNumberType() {
+    const numberType = (this.name === NUMBER_TYPE_NAME);
+
+    return numberType;
+  }
+
+  isBooleanType() {
+    const booleanType = (this.name === BOOLEAN_TYPE_NAME);
+
+    return booleanType;
+  }
+
+  isNominalValueType() {
+    const listType = (this.name === NOMINAL_VALUE_TYPE_NAME);
+
+    return listType;
+  }
+
+  isEqualTo(type) {
+    let equalTo = false;
+
+    const typeName = type.getName();
+
+    if (this.name === typeName) {
+      switch (this.name) {
+        case LIST_TYPE_NAME: {
+          const typeArgumentType = type.getArgumentType();
+
+          if ((this.argumentType === null) || (typeArgumentType === null)) {
+            if (this.argumentType === typeArgumentType) {
+              equalTo = true;
+            }
+          } else {
+            const arguemntTypeEqualToTypeArgumentType = this.argumentType.isEqualTo(typeArgumentType);
+
+            if (arguemntTypeEqualToTypeArgumentType) {
+              equalTo = true;
+            }
+          }
+
+          break;
+        }
+
+        default: {
+          equalTo = true;
+
+          break;
+        }
+      }
+    }
+
+    return equalTo;
+  }
+
+  static name = "Type";
+
+  static fromTypeName(typeName, context) {
+    let type = null;
+
+    if (typeName !== null) {
+      const node = null,  ///
+            name = typeName,  ///
+            argumentType = null,
+            typeString = typeName,  ///
+            string = typeString,  ///
+            breakPoint = null;
+
+      context = null;
+
+      type = new Type(context, string, node, breakPoint, name, argumentType);
+    }
+
+    return type;
+  }
+
+  static fromTypeNameAndArgumentTypeName(typeName, argumentTypeName, context) {
+    const node = null,  ///
+          name = typeName,  ///
+          argumentType = Type.fromTypeName(argumentTypeName, context),
+          typeString = typeStringFromTypeNameAndArgumentTypeName(typeName, argumentTypeName),
+          string = typeString,  ///
+          breakPoint = null;
+
+    context = null;
+
+    const type = new Type(context, string, node, breakPoint, name, argumentType);
+
+    return type;
+  }
+
+});