occam-verify-cli 0.0.676 → 0.0.677

package/src/constructor.js

@@ -3,11 +3,13 @@
 import Type from "./type";
 
 import { nodeAsString } from "./utilities/string";
-import { termNodeFromTermString } from "./utilities/node";
+import { termNodeFromConstructorDeclarationTokens } from "./utilities/node";
+import { constructorDeclarationTokensFromTermString } from "./utilities/tokens";
 
 export default class Constructor {
-  constructor(termNode, type) {
+  constructor(termNode, string, type) {
     this.termNode = termNode;
+    this.string = string;
     this.type = type;
   }
 
@@ -15,25 +17,12 @@ export default class Constructor {
     return this.termNode;
   }
 
-  getType() {
-    return this.type;
+  getString() {
+    return this.string;
   }
 
-  asString(tokens) {
-    let string;
-
-    const termString = nodeAsString(this.termNode, tokens);
-
-    if (this.type === null) {
-      string = `${termString}`;
-    } else {
-      const noSuperType = true,
-            typeString = this.type.asString(tokens, noSuperType);
-
-      string = `${termString}:${typeString}`;
-    }
-
-    return string;
+  getType() {
+    return this.type;
   }
 
   toJSON(tokens) {
@@ -51,8 +40,9 @@ export default class Constructor {
     return json;
   }
 
-  static fromTermNodeAndType(termNode, type) {
-    const constructor = new Constructor(termNode, type);
+  static fromTermNodeTypeAndTokens(termNode, type, tokens) {
+    const string = stringFromTermNodeTypeAndTokens(termNode, type, tokens),
+          constructor = new Constructor(termNode, string, type);
 
     return constructor;
   }
@@ -62,7 +52,8 @@ export default class Constructor {
           termString = term,  ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          termNode = termNodeFromTermString(termString, lexer, parser);
+          constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, lexer),
+          termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
 
     let { type } = json;
 
@@ -78,8 +69,27 @@ export default class Constructor {
       type = fileContext.findTypeByTypeName(typeName); ///
     }
 
-    const constructor = new Constructor(termNode, type);
+    const tokens = constructorDeclarationTokens,  ///
+          string = stringFromTermNodeTypeAndTokens(termNode, type, tokens),
+          constructor = new Constructor(termNode, string, type);
 
     return constructor;
   }
 }
+
+function stringFromTermNodeTypeAndTokens(termNode, type, tokens) {
+  let string;
+
+  const termString = nodeAsString(termNode, tokens);
+
+  if (type === null) {
+    string = `${termString}`;
+  } else {
+    const noSuperType = true,
+          typeString = type.asString(tokens, noSuperType);
+
+    string = `${termString}:${typeString}`;
+  }
+
+  return string;
+}

package/src/context/metaproof.js

@@ -16,8 +16,6 @@ class MetaproofContext {
     return this.context;
   }
 
-  getVariables() { return this.context.getVariables(); }
-
   getMetavariables() {
     const metavariables = [];
 
@@ -41,6 +39,8 @@ class MetaproofContext {
     return metaproofSteps;
   }
 
+  getVariables() { return this.context.getVariables(); }
+
   getLastMetaproofStep() {
     let lastMetaproofStep = null;
 

package/src/log.js

@@ -2,7 +2,7 @@
 
 import { levels } from "necessary";
 
-import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/tokens";
+import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/lineIndex";
 
 const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
 

package/src/node/statement/combinator/bracketed.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
-import { statementNodeFromStatementString } from "../../../utilities/node";
+import unqualifiedBracketedCombinatorStatementTokens from "../../../tokens/statement/combinator/bracketed";
 
-const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+import { statementNodeFromUnqualifiedStatementTokens } from "../../../utilities/node";
 
-const bracketedCombinatorStatementNode = statementNodeFromStatementString(bracketedCombinatorStatementString);
+const bracketedCombinatorStatementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedBracketedCombinatorStatementTokens);
 
 export default bracketedCombinatorStatementNode;

package/src/node/statement/combinator/equality.js

@@ -1,11 +1,9 @@
 "use strict";
 
-import { OBJECT_TYPE_NAME } from "../../../typeNames";
-import { statementNodeFromStatementString } from "../../../utilities/node";
+import unqualifiedEqualityCombinatorStatementTokens from "../../../tokens/statement/combinator/equality";
 
-const equalityCombinatorStatementString = `${OBJECT_TYPE_NAME} = ${OBJECT_TYPE_NAME}`;
+import { statementNodeFromUnqualifiedStatementTokens } from "../../../utilities/node";
 
-const equalityCombinatorStatementNode = statementNodeFromStatementString(equalityCombinatorStatementString);
+const equalityCombinatorStatementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedEqualityCombinatorStatementTokens);
 
 export default equalityCombinatorStatementNode;
-

package/src/ocmbinator/bracketed.js

@@ -1,13 +1,18 @@
 "use strict";
 
 import Combinator from "../combinator";
-
 import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
+import unqualifiedBracketedCombinatorStatementTokens from "../tokens/statement/combinator/bracketed";
+
+import { nodeAsString } from "../utilities/string";
 
 class BracketedCombinator extends Combinator {
   static fromNothing() {
-    const statementNode = bracketedCombinatorStatementNode,  ///
-          bracketedCombinator = new BracketedCombinator(statementNode);
+    const node = bracketedCombinatorStatementNode,  ///
+          tokens = unqualifiedBracketedCombinatorStatementTokens, ///
+          string = nodeAsString(node, tokens),
+          statementNode = node, ///
+          bracketedCombinator = new BracketedCombinator(statementNode, string);
 
     return bracketedCombinator;
   }

package/src/ocmbinator/equality.js

@@ -1,13 +1,18 @@
 "use strict";
 
 import Combinator from "../combinator";
-
 import equalityCombinatorStatementNode from "../node/statement/combinator/equality";
+import unqualifiedEqualityCombinatorStatementTokens from "../tokens/statement/combinator/equality";
+
+import { nodeAsString } from "../utilities/string";
 
 class EqualityCombinator extends Combinator {
   static fromNothing() {
-    const statementNode = equalityCombinatorStatementNode,  ///
-          equalityCombinator = new EqualityCombinator(statementNode);
+    const node = equalityCombinatorStatementNode,  ///
+          tokens = unqualifiedEqualityCombinatorStatementTokens, ///
+          string = nodeAsString(node, tokens),
+          statementNode = node, ///
+          equalityCombinator = new EqualityCombinator(statementNode, string);
 
     return equalityCombinator;
   }

package/src/tokens/statement/combinator/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
+import { unqualifiedStatementTokensFromStatementString } from "../../../utilities/tokens";
+
+const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+const unqualifiedBracketedCombinatorStatementTokens = unqualifiedStatementTokensFromStatementString(bracketedCombinatorStatementString)
+
+export default unqualifiedBracketedCombinatorStatementTokens;

package/src/tokens/statement/combinator/equality.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../../typeNames";
+import { unqualifiedStatementTokensFromStatementString } from "../../../utilities/tokens";
+
+const equalityCombinatorStatementString = `${OBJECT_TYPE_NAME} = ${OBJECT_TYPE_NAME}`;
+
+const unqualifiedEqualityCombinatorStatementTokens = unqualifiedStatementTokensFromStatementString(equalityCombinatorStatementString);
+
+export default unqualifiedEqualityCombinatorStatementTokens;

package/src/utilities/lineIndex.js

@@ -0,0 +1,51 @@
+"use strict";
+
+export function leastLineIndexFromNodeAndTokens(node, tokens) {
+  let leastLineIndex = undefined; ///
+
+  const firstSignificantToken = node.getFirstSignificantToken(),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken);
+
+  let lineIndex = 0;
+
+  tokens.some((token, tokenIndex) => {  ///
+    if (tokenIndex === firstSignificantTokenIndex) {
+      leastLineIndex = lineIndex;  ///
+
+      return true;
+    }
+
+    const tokenEndOfLineToken = token.isEndOfLineToken();
+
+    if (tokenEndOfLineToken) {
+      lineIndex += 1;
+    }
+  });
+
+  return leastLineIndex;
+}
+
+export function greatestLineIndexFromNodeAndTokens(node, tokens) {
+  let greatestLineIndex = undefined;  ///
+
+  const lastSignificantToken = node.getLastSignificantToken(),
+        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken);
+
+  let lineIndex = 0;
+
+  tokens.some((token, tokenIndex) => {  ///
+    if (tokenIndex === lastSignificantTokenIndex) {
+      greatestLineIndex = lineIndex;  ///
+
+      return true;
+    }
+
+    const tokenEndOfLineToken = token.isEndOfLineToken();
+
+    if (tokenEndOfLineToken) {
+      lineIndex += 1;
+    }
+  });
+
+  return greatestLineIndex;
+}

package/src/utilities/node.js

@@ -1,8 +1,9 @@
 "use strict";
 
-import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { TYPE_RULE_NAME,
          LABEL_RULE_NAME,
          VARIABLE_RULE_NAME,
@@ -11,14 +12,16 @@ import { TYPE_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { labelTokensFromLabelString,
+         constructorDeclarationTokensFromTermString,
+         variableDeclarationTokensFromVariableString,
+         unqualifiedStatementTokensFromStatementString,
+         metavariableDeclarationTokensFromMetavariableString,
+         unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
 
-import { combinedCustomGrammarFromNothing } from "./customGrammar";
-
-const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
-      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
@@ -30,95 +33,169 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
-        content = `Constructor ${termString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        constructorDeclarationNode = node, ///
-        termNode = termNodeQuery(constructorDeclarationNode);
+  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, parser),
+        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
 
   return termNode;
 }
 
 export function labelNodeFromLabelString(labelString, lexer, parser) {
-  const content = labelString, ///
-        ruleName = LABEL_RULE_NAME,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        labelNode = node; ///
+  const labelTokens = labelTokensFromLabelString(labelString, lexer),
+        labelNode = labelNodeFromLabelTokens(labelTokens, parser);
 
   return labelNode;
 }
 
 export function typeNodeFromVariableString(variableString, lexer, parser) {
-  const ruleName = TYPE_RULE_NAME,
-        content = `Variable ${variableString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        typeDeclarationNode = node, ///
-        typeNode = typeNodeQuery(typeDeclarationNode);
+  const variableDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
+        typeNode = typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser);
 
   return typeNode;
 }
 
 export function variableNodeFromVariableString(variableString, lexer, parser) {
-  const ruleName = VARIABLE_RULE_NAME,
-        content = `Variable ${variableString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        variableDeclarationNode = node, ///
-        variableNode = variableNodeQuery(variableDeclarationNode);
+  const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
+        variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
 
   return variableNode;
 }
 
 export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        content = `${statementString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        unqualifiedStatementNode = node,  ///
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+  const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
+        statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
 
   return statementNode;
 }
 
 export function metaTypeNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const ruleName = META_TYPE_RULE_NAME,
-        content = `Metavariable ${metavariableString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        metaTypeDeclarationNode = node, ///
-        metaTypeNode = metaTypeNodeQuery(metaTypeDeclarationNode);
+  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
+        metaTypeNode = metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
 
   return metaTypeNode;
 }
 
 export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        content = `Metavariable ${metavariableString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        metavariableDeclarationNode = node, ///
-        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode);
+  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
+        metavariableNode = metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
 
   return metavariableNode;
 }
 
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
-  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
-        content = `${metastatementString}
-`,
-        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
-        unqualifiedMetastatementNode = node,  ///
+  const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
+        metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
+
+  return metastatementNode;
+}
+
+export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
+  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
+        termNode = termNodeQuery(constructorDeclarationNode);
+
+  return termNode;
+}
+
+export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
+  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser) {
+  const typeDeclarationNode = typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser),
+        typeNode = typeNodeQuery(typeDeclarationNode);
+
+  return typeNode;
+}
+
+export function metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
+  const metaTypeDeclarationNode = metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
+        metaTypeNode = metaTypeNodeQuery(metaTypeDeclarationNode);
+
+  return metaTypeNode;
+}
+
+export function metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
+  const metavariableDeclarationNode = metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
+        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode);
+
+  return metavariableNode;
+}
+
+export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
+  const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser),
+        variableNode = variableNodeQuery(variableDeclarationNode);
+
+  return variableNode;
+}
+
+export function metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser),
         metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   return metastatementNode;
 }
 
-function nodeFromContentAndRuleName(content, ruleName, lexer = florenceLexer, parser = florenceParser) {
+export function labelNodeFromLabelTokens(labelTokens, parser) {
+  const ruleName = LABEL_RULE_NAME,
+        labelNode = nodeFromTokensRuleNameAndParser(labelTokens, ruleName, parser);
+
+  return labelNode;
+}
+
+export function typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser) {
+  const ruleName = TYPE_RULE_NAME,
+        typeDeclarationNode = nodeFromTokensRuleNameAndParser(variableDeclarationTokens, ruleName, parser);
+
+  return typeDeclarationNode;
+}
+
+export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
+  const ruleName = VARIABLE_RULE_NAME,
+        variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
+
+  return variableDeclarationNode;
+}
+
+export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
+  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);
+
+  return unqualifiedStatementNode;
+}
+
+export function metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
+  const ruleName = META_TYPE_RULE_NAME,
+        metaTypeDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
+
+  return metaTypeDeclarationNode;
+}
+
+export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
+  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
+        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
+
+  return constructorDeclarationNode;
+}
+
+export function metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
+  const ruleName = METAVARIABLE_RULE_NAME,
+        metavariableDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
+
+  return metavariableDeclarationNode;
+}
+
+export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
+  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
+        unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);
+
+  return unqualifiedMetastatementNode;
+}
+
+function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],
-        tokens = lexer.tokenise(content),
         node = parser.parse(tokens, rule);
 
   return node;

package/src/utilities/string.js

@@ -54,4 +54,3 @@ export function nodesAsString(nodes, tokens) {
 
   return string;
 }
-

package/src/utilities/tokens.js

@@ -1,51 +1,63 @@
 "use strict";
 
-export function leastLineIndexFromNodeAndTokens(node, tokens) {
-  let leastLineIndex = undefined; ///
+import { lexersUtilities } from "occam-custom-grammars";
 
-  const firstSignificantToken = node.getFirstSignificantToken(),
-        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken);
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
 
-  let lineIndex = 0;
+const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 
-  tokens.some((token, tokenIndex) => {  ///
-    if (tokenIndex === firstSignificantTokenIndex) {
-      leastLineIndex = lineIndex;  ///
+const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
+      florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-      return true;
-    }
+export function labelTokensFromLabelString(labelString, lexer) {
+  const labelContent = `${labelString}`,
+        labelTokens = tokensFromContentAndLexer(labelContent, lexer);
 
-    const tokenEndOfLineToken = token.isEndOfLineToken();
+  return labelTokens;
+}
 
-    if (tokenEndOfLineToken) {
-      lineIndex += 1;
-    }
-  });
+export function constructorDeclarationTokensFromTermString(termString, lexer) {
+  const constructorDeclarationContent = `Constructor ${termString}
+`,
+        constructorDeclarationTokens = tokensFromContentAndLexer(constructorDeclarationContent, lexer);
 
-  return leastLineIndex;
+  return constructorDeclarationTokens;
 }
 
-export function greatestLineIndexFromNodeAndTokens(node, tokens) {
-  let greatestLineIndex = undefined;  ///
+export function variableDeclarationTokensFromVariableString(variableString, lexer) {
+  const variableDeclarationContent = `Variable ${variableString}
+`,
+        variableDeclarationTokens = tokensFromContentAndLexer(variableDeclarationContent, lexer);
 
-  const lastSignificantToken = node.getLastSignificantToken(),
-        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken);
+  return variableDeclarationTokens;
+}
 
-  let lineIndex = 0;
+export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
+  const unqualifiedStatementContent = `${statementString}
+`,
+        unqualifiedStatementTokens = tokensFromContentAndLexer(unqualifiedStatementContent, lexer);
 
-  tokens.some((token, tokenIndex) => {  ///
-    if (tokenIndex === lastSignificantTokenIndex) {
-      greatestLineIndex = lineIndex;  ///
+  return unqualifiedStatementTokens;
+}
 
-      return true;
-    }
+export function metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer) {
+  const metavariableDeclarationContent = `Metavariable ${metavariableString}
+`,
+        metavariableDeclarationTokens = tokensFromContentAndLexer(metavariableDeclarationContent, lexer);
 
-    const tokenEndOfLineToken = token.isEndOfLineToken();
+  return metavariableDeclarationTokens;
+}
+
+export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
+  const unqualifiedMetastatementContent = `${metastatementString}
+`,
+        unqualifiedMetastatementTokens = tokensFromContentAndLexer(unqualifiedMetastatementContent, lexer);
+
+  return unqualifiedMetastatementTokens;
+}
 
-    if (tokenEndOfLineToken) {
-      lineIndex += 1;
-    }
-  });
+function tokensFromContentAndLexer(content, lexer = florenceLexer) {
+  const tokens = lexer.tokenise(content);
 
-  return greatestLineIndex;
+  return tokens;
 }

package/src/verify/assertion/type.js

@@ -22,7 +22,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    context.error(`The '${typeName}' type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
       const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);

package/src/verify/metastatement.js

@@ -60,6 +60,10 @@ export const metastatementVerifier = new MetastatementVerifier();
 export default function verifyMetastatement(metastatementNode, derived, metaproofContext) {
   let metastatementVerified = false;
 
+  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+
+  metaproofContext.debug(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+
   if (!metastatementVerified) {
     const nonTerminalNodeA = metastatementNode, ///
           nonTerminalNodeB = metastatementNode, ///
@@ -68,5 +72,9 @@ export default function verifyMetastatement(metastatementNode, derived, metaproo
     metastatementVerified = nonTerminalNodeVerified;  ///
   }
 
+  if (metastatementVerified) {
+    metaproofContext.debug(`Verified the '${metastatementString}' metastatement.`, metastatementNode);
+  }
+
   return metastatementVerified;
 }