occam-furtle 2.0.331 → 2.0.335

package/src/node/primitive.js

@@ -4,9 +4,56 @@ import nullNode from "../nullNode";
 import NonTerminalNode from "../nonTerminalNode";
 
 import { NULL, TRUE, FALSE } from "../constants";
+import { NODE_TYPE, STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE } from "../types";
 import { NULL_TOKEN_TYPE, NUMBER_TOKEN_TYPE, BOOLEAN_TOKEN_TYPE, STRING_LITERAL_TOKEN_TYPE } from "../tokenTypes";
 
 export default class PrimitiveNode extends NonTerminalNode {
+  getType() {
+    let type;
+
+    const node = this.getNode(),
+          number = this.getNumber(),
+          boolean = this.getBoolean(),
+          stringLiteral = this.getStringLiteral();
+
+    if (false) {
+      ///
+    } else if (node !== null) {
+      type = NODE_TYPE;
+    } else if (number !== null) {
+      type = NUMBER_TYPE;
+    } else if (boolean !== null) {
+      type = BOOLEAN_TYPE;
+    } else if (stringLiteral !== null) {
+      type = STRING_TYPE;
+    }
+
+    return type;
+  }
+
+  getValue() {
+    let value;
+
+    const node = this.getNode(),
+          number = this.getNumber(),
+          boolean = this.getBoolean(),
+          stringLiteral = this.getStringLiteral();
+
+    if (false) {
+      ///
+    } else if (node !== null) {
+      value = node; ///
+    } else if (number !== null) {
+      value = number; ///
+    } else if (boolean !== null) {
+      value = boolean;  ///
+    } else if (stringLiteral !== null) {
+      value = stringLiteral;  ///
+    }
+
+    return value;
+  }
+
   getNode() {
     let node = null;
 

package/src/utilities/element.js

@@ -5,16 +5,18 @@ import { Query } from "occam-query";
 import elements from "../elements";
 
 import { BOOLEAN_TYPE } from "../types";
-import { variableStringFromName,
+import { ternaryStringFromTerm,
+         variableStringFromName,
+         termStringFromPrimitiveAndProperties,
          procedureDeclarationStringFromProcedure,
          returnBlockStringFromReturnStatementNode,
          expressionStringFromPrimitiveAndProperties,
+         variableAssignmentStringFromTypeAndVariable,
          someStringFromVariableAndAnonymousProcedure,
          everyStringFromVariableAndAnonymousProcedure,
-         variableAssignmentStringFromVariable,
          procedureStringFromTypeLabelParametersAndReturnBlock,
-         variableAssignmentStringFromVariableAssignmentsArray,
          anonymousProcedureStringFromTypeParametersAndReturnBlock,
+         variableAssignmentStringFromTypeAndVariableAssignmentsArray,
          reduceStringFromVariableInitialExpressionAndAnonymousProcedure } from "../utilities/string";
 
 export function stepFromStepNode(stepNode, context) {
@@ -42,11 +44,22 @@ export function someFromSomeNode(someNode, context) {
 
 export function termFromTermNode(termNode, context) {
   const { Term } = elements,
-        node = termNode,  ///
-        string = context.nodeAsString(node),
         variable = variableFromTermNode(termNode, context),
         primitive = primitiveFromTermNode(termNode, context),
-        term = new Term(string, variable, primitive);
+        negatedTerm = negatedTermFromTermNode(termNode, context),
+        logicalTerm = logicalTermFromTermNode(termNode, context),
+        bracketedTerm = bracketedTermFromTermNode(termNode, context),
+        comparisonTerm = comparisonTermFromTermNode(termNode, context),
+        properties = [
+          variable,
+          negatedTerm,
+          logicalTerm,
+          bracketedTerm,
+          comparisonTerm
+        ],
+        termString = termStringFromPrimitiveAndProperties(primitive, properties, context),
+        string = termString,  ///
+        term = new Term(string, variable, primitive, negatedTerm, logicalTerm, bracketedTerm, comparisonTerm);
 
   return term;
 }
@@ -107,12 +120,12 @@ export function reduceFromReduceNode(reduceNode, context) {
 
 export function ternaryFromTernaryNode(ternaryNode, context) {
   const { Ternary } = elements,
-        node = ternaryNode, ///
-        string = context.nodeAsString(node),
-        expression = expressionFromTernaryNode(ternaryNode, context),
+        term = termFromTernaryNode(ternaryNode, context),
         ifExpression = ifExpressionFromTernaryNode(ternaryNode, context),
         elseExpression = elseExpressionFromTernaryNode(ternaryNode, context),
-        ternary = new Ternary(string, expression, ifExpression, elseExpression);
+        ternaryString = ternaryStringFromTerm(term),
+        string = ternaryString, ///
+        ternary = new Ternary(string, term, ifExpression, elseExpression);
 
   return ternary;
 }
@@ -171,12 +184,9 @@ export function primitiveFromPrimitiveNode(primitiveNode, context) {
   const { Primitive } = elements,
         primitiveString = context.nodeAsString(primitiveNode),
         string = primitiveString, ///
-        node = nodeFromPrimitiveNode(primitiveNode, context),
-        nodes = nodesFromPrimitiveNode(primitiveNode, context),
-        number = numberFromPrimitiveNode(primitiveNode, context),
-        boolean = booleanFromPrimitiveNode(primitiveNode, context),
-        stringLiteral = stringLiteralFromPrimitiveNode(primitiveNode, context),
-        primitive = new Primitive(string, node, nodes, number, boolean, stringLiteral);
+        type = typeFromPrimitiveNode(primitiveNode, context),
+        value = valueFromPrimitiveNode(primitiveNode, context),
+        primitive = new Primitive(string, type, value);
 
   return primitive;
 }
@@ -227,12 +237,12 @@ export function expressionFromExpressionNode(expressionNode, context) {
           variable,
           nodeQuery,
           nodesQuery,
-          comparisonExpression,
           returnBlock,
           procedureCall,
           negatedExpression,
           logicalExpression,
-          bracketedExpression
+          bracketedExpression,
+          comparisonExpression
         ],
         expressionString = expressionStringFromPrimitiveAndProperties(primitive, properties, context),
         string = expressionString,  ///
@@ -339,6 +349,19 @@ export function negatedExpressionFromNegatedExpressionNode(negatedExpressionNode
   return negatedExpression;
 }
 
+export function logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context) {
+  const { LogicalExpression } = elements,
+        node = logicalExpressionNode, ///
+        string = context.nodeAsString(node),
+        type = typeFromLogicalExpressionNode(logicalExpressionNode, context),
+        disjunction = disjunctionFromLogicalExpressionNode(logicalExpressionNode, context),
+        leftExpression = leftExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
+        rightExpression = rightExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
+        logicalExpression = new LogicalExpression(string, type, disjunction, leftExpression, rightExpression);
+
+  return logicalExpression;
+}
+
 export function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
   const { AnonymousProcedure } = elements,
         type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
@@ -351,6 +374,18 @@ export function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureN
   return anonymousProcedure;
 }
 
+export function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const { VariableAssignments } = elements,
+        type = typeFromVariableAssignmentsNode(variableAssignmentsNode, context),
+        variableAssignmentsArray = variableAssignmentsArrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context),
+        variableAssignmentString = variableAssignmentStringFromTypeAndVariableAssignmentsArray(type, variableAssignmentsArray),
+        array = variableAssignmentsArray, ///
+        string = variableAssignmentString,  ///
+        variableAssignments = new VariableAssignments(string, array);
+
+  return variableAssignments;
+}
+
 export function bracketedExpressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
   const { BracketedExpression } = elements,
         node = bracketedExpressionNode, ///
@@ -361,15 +396,16 @@ export function bracketedExpressionFromBracketedExpressionNode(bracketedExpressi
   return bracketedExpression;
 }
 
-export function variableAssignmentsFromVariableAssignmentsNode(variableAssignmentsNode, context) {
-  const { VariableAssignments } = elements,
-        variableAssignmentsArray = variableAssignmentsArrayFromVariableAssignmentsNode(variableAssignmentsNode, context),
-        variableAssignmentString = variableAssignmentStringFromVariableAssignmentsArray(variableAssignmentsArray),
-        array = variableAssignmentsArray, ///
-        string = variableAssignmentString,  ///
-        variableAssignments = new VariableAssignments(string, array);
+export function comparisonExpressionFromComparisonExpressionNode(comparisonExpressionNode, context) {
+  const { ComparisonExpression } = elements,
+        node = comparisonExpressionNode,  ///
+        string = context.nodeAsString(node),
+        negated = negatedFromComparisonExpressionNode(comparisonExpressionNode, context),
+        leftExpression = leftExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context),
+        rightExpression = rightExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context),
+        comparisonExpression = new ComparisonExpression(string, negated, leftExpression, rightExpression);
 
-  return variableAssignments;
+  return comparisonExpression;
 }
 
 export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
@@ -382,24 +418,19 @@ export function procedureDeclarationFromProcedureDeclarationNode(procedureDeclar
   return procedureDeclaration;
 }
 
-export function comparisonExpressionFromComparisonExpressionNode(comparisonExpressionNode, context) {
-  const { ComparisonExpression } = elements,
-        node = comparisonExpressionNode,  ///
-        string = context.nodeAsString(node),
-        negated = negatedFromComparisonExpressionNode(comparisonExpressionNode, context),
-        leftExpression = leftExpressionFromCompzrisonNode(comparisonExpressionNode, context),
-        rightExpression = rightExpressionFromCompzrisonNode(comparisonExpressionNode, context),
-        comparisonExpression = new ComparisonExpression(string, negated, leftExpression, rightExpression);
-
-  return comparisonExpression;
-}
-
 export function nameFromLabelNode(labelNode, context) {
   const name = labelNode.getName();
 
   return name;
 }
 
+export function termFromTernaryNode(ternaryNode, context) {
+  const termNode = ternaryNode.getTermNode(),
+        term = termFromTermNode(termNode, context);
+
+  return term;
+}
+
 export function variableFromSomeNode(someNode, context) {
   const variableNode = someNode.getVariableNode(), ///
         variable = variableFromVariableNode(variableNode, context);
@@ -468,16 +499,10 @@ export function nameFromReferenceNode(referenceNode, context) {
   return name;
 }
 
-export function nodeFromPrimitiveNode(primitiveNode, context) {
-  const node = primitiveNode.getNode();
+export function typeFromPrimitiveNode(primitiveNode, context) {
+  const type = primitiveNode.getType();
 
-  return node;
-}
-
-export function nodesFromPrimitiveNode(primitiveNode, context) {
-  const nodes = null;
-
-  return nodes;
+  return type;
 }
 
 export function variableFromReduceNode(reduceNode, context) {
@@ -507,10 +532,10 @@ export function queryFromNodeQueryNode(nodeQueryNode, context) {
   return query;
 }
 
-export function numberFromPrimitiveNode(primitiveNode, context) {
-  const number = primitiveNode.getNumber();
+export function valueFromPrimitiveNode(primitiveNode, context) {
+  const value = primitiveNode.getValue();
 
-  return number;
+  return value;
 }
 
 export function queryFromNodesQueryNode(nodesQueryNode, context) {
@@ -533,10 +558,41 @@ export function everyFromExpressionNode(expressionNode, context) {
   return every;
 }
 
-export function booleanFromPrimitiveNode(primitiveNode, context) {
-  const boolean = primitiveNode.getBoolean();
+export function negatedTermFromTermNode(termNode, context) {
+  let negatedTerm = null;
+
+  const negatedTermNode = termNode.getNegatedTermNode();
+
+  if (negatedTermNode !== null) {
+    negatedTerm = negatedTermFromNegatedTermNode(negatedTermNode, context);
+  }
+
+  return negatedTerm;
+}
+
+export function logicalTermFromTermNode(termNode, context) {
+  let logicalTerm = null;
 
-  return boolean;
+  const logicalTermNode = termNode.getLogicalTermNode();
+
+  if (logicalTermNode !== null) {
+    logicalTerm = logicalTermFromLogicalTermNode(logicalTermNode, context);
+  }
+
+  return logicalTerm;
+}
+
+export function typeFromLogicalTermNode(logicalTermNode, context) {
+  const type = BOOLEAN_TYPE;
+
+  return type;
+}
+
+export function termFromNegatedTermNode(negatedTermNode, context) {
+  const termNode = negatedTermNode.getTermNode(),
+    term = termFromTermNode(termNode, context);
+
+  return term;
 }
 
 export function expressionFromReduceNode(reduceNode, context) {
@@ -569,13 +625,6 @@ export function stepsFromReturnBlockNode(returnBlockNode, context) {
   return steps;
 }
 
-export function expressionFromTernaryNode(ternaryNode, context) {
-  const expressionNode = ternaryNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
-
-  return expression;
-}
-
 export function variableFromNodeQueryNode(nodeQueryNode, context) {
   const variableNode = nodeQueryNode.getVariableNode(),
         variable = variableFromVariableNode(variableNode, context);
@@ -595,6 +644,37 @@ export function ternaryFromExpressionNode(expressionNode, context) {
   return ternary;
 }
 
+export function bracketedTermFromTermNode(termNode, context) {
+  let bracketedTerm = null;
+
+  const bracketedTermNode = termNode.getBracketedTermNode();
+
+  if (bracketedTermNode !== null) {
+    bracketedTerm = bracketedTermFromBracketedTermNode(bracketedTermNode, context);
+  }
+
+  return bracketedTerm;
+}
+
+export function termFromBracketedTermNode(bracketedTermNode, context) {
+  const termNode = bracketedTermNode.getTermNode(),
+    term = termFromTermNode(termNode, context);
+
+  return term;
+}
+
+export function comparisonTermFromTermNode(termNOde, context) {
+  let comparisonTerm = null;
+
+  const comparisonTermNode = termNOde.getComparisonTermNode();
+
+  if (comparisonTermNode !== null) {
+    comparisonTerm = comparisonTermFromComparisonTermNode(comparisonTermNode, context);
+  }
+
+  return comparisonTerm;
+}
+
 export function expressionFromVariableNode(variableNode, context) {
   const expression = null;
 
@@ -639,6 +719,13 @@ export function nameFromNamedParameterNode(namedParameterNode, context) {
   return name;
 }
 
+export function leftTermFromLogicalTermNode(logicalTermNode, context) {
+  const leftTermNode = logicalTermNode.getLeftTermNode(),
+    leftTerm = termFromTermNode(leftTermNode, context);
+
+  return leftTerm;
+}
+
 export function arrayAssignmentFromStepNode(stepNode, context) {
   let arrayAssignment = null;
 
@@ -719,6 +806,19 @@ export function nodesQueryFromExpressionNode(expressionNode, context) {
   return nodesQuery;
 }
 
+export function rightTermFromLogicalTermNode(logicalTermNode, context) {
+  const rightTermNode = logicalTermNode.getRightTermNode(),
+       rightTerm = termFromTermNode(rightTermNode, context);
+
+  return rightTerm;
+}
+
+export function negatedFromComparisonTermNode(comparisonTermNode, context) {
+  const negated = comparisonTermNode.isNegated();
+
+  return negated;
+}
+
 export function elseExpressionFromTernaryNode(ternaryNode, context) {
   const elseExpressionNode = ternaryNode.getElseExpressionNode(),
         elseExpression = expressionFromExpressionNode(elseExpressionNode, context);
@@ -744,7 +844,7 @@ export function typeFromNegatedExpressionNode(negatedExpressionNode, context) {
   return type;
 }
 
-export function typeFromLogcialExpressionNode(logicalExpressionNode, context) {
+export function typeFromLogicalExpressionNode(logicalExpressionNode, context) {
   const type = BOOLEAN_TYPE;
 
   return type;
@@ -770,10 +870,42 @@ export function referenceFromProcedureCallNode(procedureCallNode, context) {
   return reference;
 }
 
-export function stringLiteralFromPrimitiveNode(primitiveNode, context) {
-  const stringLiteral = primitiveNode.getStringLiteral();
+export function leftTermFromCompzrisonTermNode(comparisonTermNode, context) {
+  const leftTermNode = comparisonTermNode.getLeftTermNode(),
+        leftTerm = termFromTermNode(leftTermNode, context);
 
-  return stringLiteral;
+  return leftTerm;
+}
+
+export function disjunctionFromLogicalTermNode(logicalTermNode, context) {
+  const disjunction = logicalTermNode.isDisjunction();
+
+  return disjunction;
+}
+
+export function negatedTermFromNegatedTermNode(negatedTermNode, context) {
+  const { NegatedTerm } = elements,
+        node = negatedTermNode, ///
+        string = context.nodeAsString(node),
+        termNode = negatedTermNode.getTermNode(),
+        type = typeFromNegatedTermNode(termNode, context),
+        term = termFromNegatedTermNode(negatedTermNode, context),
+        negatedTerm = new NegatedTerm(string, type, term);
+
+  return negatedTerm;
+}
+
+export function logicalTermFromLogicalTermNode(logicalTermNode, context) {
+  const { LogicalTerm } = elements,
+        node = logicalTermNode, ///
+        string = context.nodeAsString(node),
+        type = typeFromLogicalTermNode(logicalTermNode, context),
+        disjunction = disjunctionFromLogicalTermNode(logicalTermNode, context),
+        leftTerm = leftTermFromLogicalTermNode(logicalTermNode, context),
+        rightTerm = rightTermFromLogicalTermNode(logicalTermNode, context),
+        logicalTerm = new LogicalTerm(string, type, disjunction, leftTerm, rightTerm);
+
+  return logicalTerm;
 }
 
 export function variableFromTypeAndVariableNode(type, variableNode, context) {
@@ -825,6 +957,13 @@ export function procedureCallFromExpressionNode(expressionNode, context) {
   return procedureCall;
 }
 
+export function rightTermFromCompzrisonTermNode(comparisonTermNode, context) {
+  const rightTermNode = comparisonTermNode.getLeftTermNode(),
+        rightTerm = termFromTermNode(rightTermNode, context);
+
+  return rightTerm;
+}
+
 export function variableFromArrayAssignmentNode(arrayAssignmentNode, context) {
   const variableNode = arrayAssignmentNode.getVariableNode(),
         variable = variableFromVariableNode(variableNode, context);
@@ -832,6 +971,12 @@ export function variableFromArrayAssignmentNode(arrayAssignmentNode, context) {
   return variable;
 }
 
+export function typeFromVariableAssignmentsNode(variableAssignmentsNode, context) {
+  const type = variableAssignmentsNode.getType();
+
+  return type;
+}
+
 export function anonymousProcedureFromReduceNode(reduceNode, context) {
   const anonymousProcedureNode = reduceNode.getAnonymousProcedureNode(),
         anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
@@ -839,13 +984,6 @@ export function anonymousProcedureFromReduceNode(reduceNode, context) {
   return anonymousProcedure;
 }
 
-export function leftExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
-  const leftExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
-        leftExpression = expressionFromExpressionNode(leftExpressionNode, context);
-
-  return leftExpression;
-}
-
 export function variableFromObjectAssignmentNode(objectAssignmentNode, context) {
   const variableNode = objectAssignmentNode.getVariableNode(),
         variable = variableFromVariableNode(variableNode, context);
@@ -865,13 +1003,6 @@ export function expressionFromTypeAndVariableNode(type, variableNode, context) {
   return expression;
 }
 
-export function rightExpressionFromCompzrisonNode(comparisonExpressionNode, context) {
-  const rightExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
-        rightExpression = expressionFromExpressionNode(rightExpressionNode, context);
-
-  return rightExpression;
-}
-
 export function parametersFromArrayAssignmentNode(arrayAssignmentNode, context) {
   const parametersNode = arrayAssignmentNode.getParametersNode(),
         parameters = parametersFromParametersNode(parametersNode, context);
@@ -893,6 +1024,16 @@ export function returnStatementFromReturnBlockNode(returnBlockNode, context) {
   return returnStatement;
 }
 
+export function bracketedTermFromBracketedTermNode(bracketedTermNode, context) {
+  const { BracketedTerm } = elements,
+        node = bracketedTermNode, ///
+        string = context.nodeAsString(node),  ///
+        term = termFromBracketedTermNode(bracketedTermNode, context),
+        bracketedTerm = new BracketedTerm(string, term);
+
+  return bracketedTerm;
+}
+
 export function negatedExpressionFromExpressionNode(expressionNode, context) {
   let negatedExpression = null;
 
@@ -905,16 +1046,11 @@ export function negatedExpressionFromExpressionNode(expressionNode, context) {
   return negatedExpression;
 }
 
-export function logicalExpressionFromExpressionNode(expressionNode, context) {
-  let logicalExpression = null;
-
-  const logicalExpressionNode = expressionNode.getLogicalExpressionNode();
-
-  if (logicalExpressionNode !== null) {
-    logicalExpression = logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context);
-  }
+export function expressionFromNegatedExpressionNode(negatedExpressionNode, context) {
+  const expressionNode = negatedExpressionNode.getExpressionNode(),
+        expression = expressionFromExpressionNode(expressionNode, context);
 
-  return logicalExpression;
+  return expression;
 }
 
 export function negatedFromComparisonExpressionNode(comparisonExpressionNode, context) {
@@ -923,11 +1059,16 @@ export function negatedFromComparisonExpressionNode(comparisonExpressionNode, co
   return negated;
 }
 
-export function expressionFromNegatedExpressionNode(negatedExpressionNode, context) {
-  const expressionNode = negatedExpressionNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
+export function logicalExpressionFromExpressionNode(expressionNode, context) {
+  let logicalExpression = null;
 
-  return expression;
+  const logicalExpressionNode = expressionNode.getLogicalExpressionNode();
+
+  if (logicalExpressionNode !== null) {
+    logicalExpression = logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context);
+  }
+
+  return logicalExpression;
 }
 
 export function expressionFromVariableAssignmentNode(variableAssigmentNode, context) {
@@ -950,6 +1091,18 @@ export function parametersFromAnonymousProcedureNode(anonymousProcedureNode, con
   return parameters;
 }
 
+export function comparisonTermFromComparisonTermNode(comparisonTermNode, context) {
+  const { ComparisonTerm } = elements,
+        node = comparisonTermNode,  ///
+        string = context.nodeAsString(node),
+        negated = negatedFromComparisonTermNode(comparisonTermNode, context),
+        leftTerm = leftTermFromCompzrisonTermNode(comparisonTermNode, context),
+        rightTerm = rightTermFromCompzrisonTermNode(comparisonTermNode, context),
+        comparisonTerm = new ComparisonTerm(string, negated, leftTerm, rightTerm);
+
+  return comparisonTerm;
+}
+
 export function returnBlockFromAnonymousProcedureNode(anonymousProcedureNode, context) {
   const returnBlockNode = anonymousProcedureNode.getReturnBlockNode(),
         returnBlock = returnBlockFromReturnBlockNode(returnBlockNode, context);
@@ -957,6 +1110,19 @@ export function returnBlockFromAnonymousProcedureNode(anonymousProcedureNode, co
   return returnBlock;
 }
 
+export function procedureFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { Procedure } = elements,
+        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        label = labelFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        parameters = parametersFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        returnBlock = returnBlockFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        procedureString = procedureStringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
+        string = procedureString, ///
+        procedure = new Procedure(string, type, label, parameters, returnBlock);
+
+  return procedure;
+}
+
 export function bracketedExpressionFromExpressionNode(expressionNode, context) {
   let bracketedExpression = null;
 
@@ -971,24 +1137,11 @@ export function bracketedExpressionFromExpressionNode(expressionNode, context) {
 
 export function expressionFromBracketedExpressionNode(bracketedExpressionNode, context) {
   const expressionNode = bracketedExpressionNode.getExpressionNode(),
-        expression = expressionFromExpressionNode(expressionNode, context);
+    expression = expressionFromExpressionNode(expressionNode, context);
 
   return expression;
 }
 
-export function procedureFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const { Procedure } = elements,
-        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        label = labelFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        parameters = parametersFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        returnBlock = returnBlockFromProcedureDeclarationNode(procedureDeclarationNode, context),
-        procedureString = procedureStringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
-        string = procedureString, ///
-        procedure = new Procedure(string, type, label, parameters, returnBlock);
-
-  return procedure;
-}
-
 export function comparisonExpressionFromExpressionNode(expressionNOde, context) {
   let comparisonExpression = null;
 
@@ -1042,24 +1195,25 @@ export function variableFromTypeAndVariableAssignmentNode(type, variableAssignme
   return variable;
 }
 
-export function logicalExpressionFromLogicalExpressionNode(logicalExpressionNode, context) {
-  const { LogicalExpression } = elements,
-        node = logicalExpressionNode, ///
-        string = context.nodeAsString(node),
-        type = typeFromLogcialExpressionNode(logicalExpressionNode, context),
-        disjunction = disjunctionFromLogicalExpressionNode(logicalExpressionNode, context),
-        leftExpression = leftExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
-        rightExpression = rightExpressionFromLogicalExpressionNode(logicalExpressionNode, context),
-        logicalExpression = new LogicalExpression(string, type, disjunction, leftExpression, rightExpression);
+export function leftExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context) {
+  const leftExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
+        leftExpression = expressionFromExpressionNode(leftExpressionNode, context);
 
-  return logicalExpression;
+  return leftExpression;
+}
+
+export function rightExpressionFromCompzrisonExpressionNode(comparisonExpressionNode, context) {
+  const rightExpressionNode = comparisonExpressionNode.getLeftExpressionNode(),
+        rightExpression = expressionFromExpressionNode(rightExpressionNode, context);
+
+  return rightExpression;
 }
 
 export function variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context) {
   const { VariableAssignment } = elements,
         variable = variableFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context),
         expression = expressionFromVariableAssignmentNode(variableAssignmentNode, context),
-        variableAssignmentString = variableAssignmentStringFromVariable(expression, variable, context),
+        variableAssignmentString = variableAssignmentStringFromTypeAndVariable(type, variable, context),
         string = variableAssignmentString,  ///
         assignment = new VariableAssignment(string, variable, expression);
 
@@ -1097,9 +1251,8 @@ export function namedParamtersArrayFromNamedParameterNodes(namedParameterNodes,
   return namedParamtersArray;
 }
 
-export function variableAssignmentsArrayFromVariableAssignmentsNode(variableAssignmentsNode, context) {
-  const type = variableAssignmentsNode.getType(),
-        variableAssignmentNodes = variableAssignmentsNode.getVariableAssignmentNodes(),
+export function variableAssignmentsArrayFromTypeAndVariableAssignmentsNode(type, variableAssignmentsNode, context) {
+  const variableAssignmentNodes = variableAssignmentsNode.getVariableAssignmentNodes(),
         variableAssignmentsArray = variableAssignmentNodes.map((variableAssignmentNode) => {
           const variableAssignment = variableAssignmentFromTypeAndVariableAssignmentNode(type, variableAssignmentNode, context);