occam-verify-cli 0.0.317 → 0.0.319

package/src/context/proof.js

@@ -1,11 +1,14 @@
 "use strict";
 
-export default class ProofContext {
-  constructor(context, derived, variables, statementNodes) {
+import fileMixins from "../mixins/file";
+import loggingMixins from "../mixins/logging";
+import callbacksMixins from "../mixins/callbacks";
+
+class ProofContext {
+  constructor(context, derived, assertions) {
     this.context = context;
     this.derived = derived;
-    this.variables = variables;
-    this.statementNodes = statementNodes;
+    this.assertions = assertions;
   }
 
   getContext() {
@@ -16,50 +19,15 @@ export default class ProofContext {
     return this.derived;
   }
 
-  getVariables() {
-    return this.variables;
-  }
-
-  getStatementNodes() {
-    return this.statementNodes;
-  }
-
-  getRules() { return this.context.getRules(); }
-
-  getTypes() { return this.context.getTypes(); }
-
-  getAxioms() { return this.context.getAxioms(); }
+  getAssertions() {
+    let assertions = this.context.getAssertions();
 
-  getCombinators() { return this.context.getCombinators(); }
+    assertions = [
+      ...assertions,
+      ...this.assertions
+    ];
 
-  getConstructors() { return this.context.getConstructors(); }
-
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
-
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variable = this.variables.find((variable) => {
-            const matches = variable.matchName(name);
-
-            if (matches) {
-              return true;
-            }
-          }) || this.context.findVariableByVariableName(variableName);  ///
-
-    return variable;
-  }
-
-  isLabelPresent(label) { return this.context.isLabelPresent(label); }
-
-  isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
+    return assertions;
   }
 
   setDerived(derived) {
@@ -70,34 +38,53 @@ export default class ProofContext {
     this.derived = derived;
   }
 
-  addAxiom(axiom) { this.context.addAxiom(axiom); }
-
-  addVariable(variable) {
-    this.variables.push(variable);
+  addAssertion(assertion) {
+    this.assertions.push(assertion);
   }
 
-  addStatementNode(statementNode) {
-    this.statementNodes.push(statementNode);
-  }
+  matchAssertion(assertion) {
+    let assertionMatches;
 
-  trace(message, node) { this.context.trace(message, node); }
+    const assertionB = assertion; ///
 
-  debug(message, node) { this.context.debug(message, node); }
+    assertionMatches = this.assertions.some((assertion) => {
+      const assertionA = assertion, ///
+            matches = assertionA.match(assertionB);
 
-  info(message, node) { this.context.info(message, node); }
+      if (matches) {
+        return true;
+      }
+    });
 
-  warning(message, node) { this.context.warning(message, node); }
+    if (!assertionMatches) {
+      assertionMatches = this.context.matchAssertion(assertion);
+    }
 
-  error(message, node) { this.context.error(message, node); }
+    return assertionMatches;
+  }
 
-  fatal(message, node) { this.context.fatal(message, node); }
+  static fromFileContext(fileContext) {
+    const context = fileContext,  ///
+          derived = false,
+          assertions = [],
+          proofContext = new ProofContext(context, derived, assertions);
 
-  static fromContext(context) {
-    const derived = false,
-          variables = [],
-          statementNodes = [],
-          proofContext = new ProofContext(context, derived, variables, statementNodes);
+    return proofContext;
+  }
+
+  static fromProofContext(proofContext) {
+    const context = proofContext,  ///
+          derived = false,
+          assertions = [];
+
+    proofContext = new ProofContext(context, derived, assertions);  ///
 
     return proofContext;
   }
 }
+
+Object.assign(ProofContext.prototype, fileMixins);
+Object.assign(ProofContext.prototype, loggingMixins);
+Object.assign(ProofContext.prototype, callbacksMixins);
+
+export default ProofContext;

package/src/context/release.js

@@ -2,21 +2,19 @@
 
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import logMixins from "../mixins/log";
-
 import { push } from "../utilities/array";
 import { customGrammarFromRelease, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
-class ReleaseContext {
-  constructor(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
+export default class ReleaseContext {
+  constructor(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
     this.log = log;
     this.release = release;
+    this.callbacks = callbacks;
     this.verified = verified;
     this.customGrammar = customGrammar;
-
     this.fileContexts = fileContexts;
     this.florenceLexer = florenceLexer;
     this.florenceParser = florenceParser;
@@ -31,6 +29,10 @@ class ReleaseContext {
     return this.release;
   }
 
+  getCallbacks() {
+    return this.callbacks;
+  }
+
   isVerified() {
     return this.verified;
   }
@@ -65,6 +67,8 @@ class ReleaseContext {
 
   getDependencies() { return this.release.getDependencies(); }
 
+  matchShortenedVersion(shortenedVersion) { return this.release.matchShortenedVersion(shortenedVersion); }
+
   getRules(releaseNames = []) {
     const name = this.getName(),
           rules = [],
@@ -204,10 +208,32 @@ class ReleaseContext {
     this.fileContexts.push(fileContext);
   }
 
+  setVerified(verified) {
+    this.verified = verified;
+  }
+
   tokenise(content) { return this.florenceLexer.tokenise(content); }
 
   parse(tokens) { return this.florenceParser.parse(tokens); }
 
+  trace(message) { this.log.trace(message); }
+
+  debug(message) { this.log.debug(message); }
+
+  info(message) { this.log.info(message); }
+
+  warning(message) { this.log.warning(message); }
+
+  error(message) { this.log.error(message); }
+
+  fatal(message) { this.log.fatal(message); }
+
+  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }
+
+  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }
+
+  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
+
   initialise(releaseContexts, dependencyReleaseContexts) {
     const releaseContext = this;  ///
 
@@ -222,19 +248,15 @@ class ReleaseContext {
     this.releaseContexts = releaseContexts;
   }
 
-  static fromLogAndRelease(log, release, ...remainingArguments) {
+  static fromLogReleaseAndCallbacks(log, release, callbacks, ...remainingArguments) {
     const verified = false,
           customGrammar = customGrammarFromRelease(release),
           fileContexts = [],
           florenceLexer = null,
           florenceParser = null,
           releaseContexts = [],
-          releaseContext = new ReleaseContext(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
+          releaseContext = new ReleaseContext(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
 
     return releaseContext;
   }
 }
-
-Object.assign(ReleaseContext.prototype, logMixins);
-
-export default ReleaseContext;

package/src/index.js

@@ -1,4 +1,7 @@
 "use strict";
 
+export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
+
+export { default as verificationUtilities } from "./utilities/verification";

package/src/mixins/callbacks.js

@@ -0,0 +1,15 @@
+"use strict";
+
+function halt(node) { this.context.halt(node); }
+
+function begin(node) { this.context.begin(node); }
+
+function complete(node) { this.context.complete(node); }
+
+const callbacksMixins = {
+  halt,
+  begin,
+  complete
+};
+
+export default callbacksMixins;

package/src/mixins/file.js

@@ -0,0 +1,12 @@
+"use strict";
+
+function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
+
+function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
+
+const fileMixins = {
+  findRuleByReferenceName,
+  findAxiomByReferenceName
+};
+
+export default fileMixins;

package/src/mixins/logging.js

@@ -0,0 +1,24 @@
+"use strict";
+
+function trace(message) { this.context.trace(message); }
+
+function debug(message) { this.context.debug(message); }
+
+function info(message) { this.context.info(message); }
+
+function warning(message) { this.context.warning(message); }
+
+function error(message) { this.context.error(message); }
+
+function fatal(message) { this.context.fatal(message); }
+
+const loggingMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal
+};
+
+export default loggingMixins;

package/src/rule.js

@@ -23,7 +23,7 @@ export default class Rule {
     return this.conclusion;
   }
 
-  matchMetastatement(metastatementNode, context) {
+  matchMetastatement(metastatementNode, metaproofContext) {
     let metastatementNatches;
 
     const premisesLength = this.premises.length;
@@ -34,7 +34,7 @@ export default class Rule {
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaAssertions = context.getMetaAssertions();
+      const metaAssertions = metaproofContext.getMetaAssertions();
 
       metastatementNatches = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
         const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);

package/src/utilities/verification.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { first } = arrayUtilities;
+
+export function checkCyclicDependencyExists(name, dependentNames, releaseContext) {
+  const dependentNamesIncludesName = dependentNames.includes(name),
+        cyclicDependencyExists = dependentNamesIncludesName;  ///
+
+  if (cyclicDependencyExists) {
+    const firstDependentName = first(dependentNames),
+          dependencyNames = dependentNames.concat(firstDependentName),
+          dependencyNamesString = dependencyNames.join(`' -> '`);
+
+    releaseContext.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);
+  }
+
+  return cyclicDependencyExists;
+}
+
+export function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
+  const release = releaseContext.getRelease(),
+        releaseMatchesShortedVersion = release.matchShortenedVersion(shortenedVersion);
+
+  if (!releaseMatchesShortedVersion) {
+    const name = releaseContext.getName(),
+          version = releaseContext.getVersion(),
+          versionString = version.toString(),
+          shortenedVersionString = shortenedVersion.toString();
+
+    releaseContext.error(`The '${name}' package's version of ${versionString} does not match the dependency's shortened version of ${shortenedVersionString}.`);
+  }
+
+  return releaseMatchesShortedVersion;
+}
+
+export default {
+  checkCyclicDependencyExists,
+  checkReleaseMatchesShortenedVersion
+};

package/src/verify/IndicativeConditional.js

@@ -1,20 +1,29 @@
 "use strict";
 
-import verifyUnqualifiedStatement from "../verify/metastatement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodesQuery } from "../utilities/query";
 
 const unqualifiedStatementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement");
 
-export default function verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context) {
-  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(indicativeConditionalNode),
-        indicativeConditionalVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
-          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+export default function verifyIndicativeConditional(indicativeConditionalNode, statementNodes, proofContext) {
+  let indicativeConditionalVerified;
 
-          if (unqualifiedStatementVerified) {
-            return true;
-          }
-        });
+  proofContext.begin(indicativeConditionalNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(indicativeConditionalNode);
+
+  indicativeConditionalVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  indicativeConditionalVerified ?
+    proofContext.complete(indicativeConditionalNode) :
+      proofContext.halt(indicativeConditionalNode);
 
   return indicativeConditionalVerified;
 }

package/src/verify/assertion/type.js

@@ -9,17 +9,19 @@ import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, context) {
+export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
   let typeAssertionVerified = false;
 
+  proofContext.begin(typeAssertionNode);
+
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
+        typePresent = proofContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    proofContext.error(`The ${typeName} type is not present.`);
   } else {
-    const derived = context.isDerived();
+    const derived = proofContext.isDerived();
 
     if (derived) {
       debugger
@@ -27,6 +29,7 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
       const types = [],
             names = [],
             values = [],
+            context = proofContext, ///
             termNode = termNodeQuery(typeAssertionNode),
             termVerified = verifyTermAsVariable(termNode, types, names, values, context);
 
@@ -37,20 +40,20 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
               value = firstValue;
 
         if (value !== undefined) {
-          context.error(`The value of the ${variableName} variable is not undefined.`, typeAssertionNode);
+          proofContext.error(`The value of the ${variableName} variable is not undefined.`);
         } else {
-          const type = context.findTypeByTypeName(typeName),
+          const type = proofContext.findTypeByTypeName(typeName),
                 firstType = first(types),
                 variableType = firstType, ///
                 typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
 
           if (!typeSubTypeOfVariableType) {
-            context.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`, typeAssertionNode);
+            proofContext.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
           } else {
             const name = variableName,  ///
                   variable = Variable.fromTypeAndName(type, name);
 
-            context.addVariable(variable);
+            proofContext.addVariable(variable);
 
             typeAssertionVerified = true;
           }
@@ -59,5 +62,9 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
     }
   }
 
+  typeAssertionVerified ?
+    proofContext.complete(typeAssertionNode) :
+      proofContext.halt(typeAssertionNode);
+
   return typeAssertionVerified;
 }

package/src/verify/axiom.js

@@ -13,30 +13,28 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
       unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
       indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
 
-export default function verifyAxiom(axiomNode, context) {
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = nodesAsString(labelNodes);
-
-  context.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
-
-  const proofContext = ProofContext.fromContext(context);
+export default function verifyAxiom(axiomNode, fileContext) {
+  let axiomVerified = false;
 
-  context = proofContext; ///
+  fileContext.begin(axiomNode);
 
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
+  const labelNodes = labelNodesQuery(axiomNode),
+        labelsString = nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
         indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
 
-  let axiomVerified = false;
+  fileContext.debug(`Verifying the '${labelsString}' axiom...`);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
 
     if (unqualifiedStatementVerified) {
       const statementNode = statementNodeQuery(unqualifiedStatementNode),
             labels = labelsString,  ///
             axiom = Axiom.fromStatementNodeAndLabels(statementNode, labels);
 
-      context.addAxiom(axiom);
+      fileContext.addAxiom(axiom);
 
       axiomVerified = true;
     }
@@ -44,7 +42,7 @@ export default function verifyAxiom(axiomNode, context) {
 
   if (indicativeConditionalNode !== null) {
     const statementNodes = [],
-          indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context);
+          indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, statementNodes, proofContext);
 
     if (indicativeConditionalVerified !== null) {
       const labels = labelsString,  ///
@@ -54,15 +52,15 @@ export default function verifyAxiom(axiomNode, context) {
             consequentStatementNode = secondStatementNode,  ///
             axiom = Axiom.fromSuppositionStatementNodeConsequentStatementNodeAndLabels(suppositionStatementNode, consequentStatementNode, labels);
 
-      context.addAxiom(axiom);
+      fileContext.addAxiom(axiom);
 
       axiomVerified = true;
     }
   }
 
-  if (axiomVerified) {
-    context.info(`Verified the '${labelsString}' axiom.`, axiomNode);
-  }
+  axiomVerified ?
+    fileContext.complete(axiomNode) :
+      fileContext.halt(axiomNode);
 
   return axiomVerified;
 }

package/src/verify/conclusion.js

@@ -8,13 +8,15 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
-export default function verifyConclusion(conclusionNode, conclusions, context) {
+export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
   let conclusionVerified = false;
 
+  metaproofContext.begin(conclusionNode);
+
   const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
 
   if (unqualifiedMetastatementNode !== null) {
-    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
     if (unqualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
@@ -26,5 +28,9 @@ export default function verifyConclusion(conclusionNode, conclusions, context) {
     }
   }
 
+  conclusionVerified ?
+    metaproofContext.complete(conclusionNode) :
+      metaproofContext.halt(conclusionNode);
+
   return conclusionVerified;
 }

package/src/verify/conditinalInference.js

@@ -8,18 +8,24 @@ import { nodeQuery } from "../utilities/query";
 const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
       premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
 
-export default function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
+export default function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, metaproofContext) {
   let conditionalInferenceVerified = false;
 
+  metaproofContext.begin(conditionalInferenceNode);
+
   const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
         premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
-        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
+        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, metaproofContext);
 
   if (premiseOrPremisesVerified) {
-    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, metaproofContext);
 
-    conditionalInferenceVerified = conclusionVerified;
+    conditionalInferenceVerified = conclusionVerified;  ///
   }
 
+  conditionalInferenceVerified ?
+    metaproofContext.complete(conditionalInferenceNode) :
+      metaproofContext.halt(conditionalInferenceNode);
+
   return conditionalInferenceVerified;
 }

package/src/verify/declaration/combinator.js

@@ -6,10 +6,19 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
-export default function verifyCombinatorDeclaration(combinatorDeclarationNode, context) {
+export default function verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext) {
+  let combinatorDeclarationVerified;
+
+  fileContext.begin(combinatorDeclarationNode);
+
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
-        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, context),
-        combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
+        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
+
+  combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
+
+  combinatorDeclarationVerified ?
+    fileContext.complete(combinatorDeclarationNode) :
+      fileContext.halt(combinatorDeclarationNode);
 
   return combinatorDeclarationVerified;
 }

package/src/verify/declaration/constructor.js

@@ -7,11 +7,20 @@ import { nodeQuery } from "../../utilities/query";
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
 
-export default function verifyConstructorDeclaration(constructorDeclarationNode, context) {
+export default function verifyConstructorDeclaration(constructorDeclarationNode, fileContext) {
+  let constructorDeclarationVerified;
+
+  fileContext.begin(constructorDeclarationNode);
+
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
-        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, context),
-        constructorDeclarationVerified = termVerifiedAsConstructor; ///
+        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
+
+  constructorDeclarationVerified = termVerifiedAsConstructor; ///
+
+  constructorDeclarationVerified ?
+    fileContext.complete(constructorDeclarationNode) :
+      fileContext.halt(constructorDeclarationNode);
 
   return constructorDeclarationVerified;
 }