occam-verify-cli 0.0.676 → 0.0.677

package/src/verify/statement.js

@@ -82,7 +82,7 @@ class StatementVerifier extends Verifier {
     if (termNode === null) {
       const argumentString = context.nodeAsString(argumentNode);
 
-      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+      context.error(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
     } else {
       const types = [],
             termVerified = verifyTerm(termNode, types, context);
@@ -143,6 +143,10 @@ export const statementVerifier = new StatementVerifier();
 export default function verifyStatement(statementNode, assignments, derived, context) {
   let statementVerified = false;
 
+  const statementString = context.nodeAsString(statementNode);
+
+  context.debug(`Verifying the '${statementString}' statement...`, statementNode);
+
   if (!statementVerified) {
     const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
 
@@ -167,12 +171,20 @@ export default function verifyStatement(statementNode, assignments, derived, con
     statementVerified = statementVerifiedAsEquality;  //
   }
 
+  if (statementVerified) {
+    context.debug(`Verified the '${statementString}' statement.`, statementNode);
+  }
+
   return statementVerified;
 }
 
 export function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement against combinators.`, statementNode);
+
   let combinators = context.getCombinators();
 
   combinators = [ ///
@@ -196,8 +208,13 @@ export function verifyStatementAgainstCombinators(statementNode, context) {
 }
 
 export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const statementString = context.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+
   const combinatorStatementNode = combinator.getStatementNode(),
-        nonTerminalNodeA = statementNode,  ///
+        nonTerminalNodeA = statementNode, ///
         nonTerminalNodeB = combinatorStatementNode, ///
         nonTerminalNodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context),
         statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///

package/src/verify/statementAsCombinator.js

@@ -19,7 +19,8 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
         childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
   if (childNodesVerified) {
-    const combinator = Combinator.fromStatementNode(statementNode);
+    const tokens = fileContext.getTokens(),
+          combinator = Combinator.fromStatementNodeAndTokens(statementNode, tokens);
 
     fileContext.addCombinator(combinator);
 

package/src/verify/term.js

@@ -68,7 +68,7 @@ class TermVerifier extends Verifier {
     if (typeNode !== null) {
       const argumentString = context.nodeAsString(argumentNode);
 
-      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+      context.error(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
     } else {
       const termNode = termNodeQuery(argumentNode),
             constructorTermNode = termNodeQuery(constructorArgumentNode),
@@ -88,15 +88,19 @@ class TermVerifier extends Verifier {
 
         if (termVerified) {
           const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
+                firstType = first(types),
+                termType = firstType, ///
+                termTypeName = termType.getName(),
                 constructorType = (constructorTypeName === OBJECT_TYPE_NAME) ?
                                     objectType :
                                       context.findTypeByTypeName(constructorTypeName),
-                firstType = first(types),
-                termType = firstType, ///
-                type = constructorType, ///
-                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 
           if (termTypeEqualToOrSubTypeOfType) {
+            const termString = context.nodeAsString(termNode);
+
+            context.trace(`The '${termTypeName}' type of the '${termString}' term is equal to or a sub-type of the '${constructorTypeName}' type in the constructor.`, argumentNode);
+
             argumentNodeVerified = true;
           }
         }
@@ -114,7 +118,7 @@ export default function verifyTerm(termNode, types, context) {
 
   const termString = context.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term...`, termNode);
+  context.debug(`Verifying the '${termString}' term...`, termNode);
 
   if (!termVerified) {
     const variables = [],
@@ -140,7 +144,11 @@ export default function verifyTerm(termNode, types, context) {
   }
 
   if (termVerified) {
-    context.debug(`Verified the '${termString}' term.`, termNode);
+    const firstType = first(types),
+          type = firstType, ///
+          typeName = type.getName();
+
+    context.debug(`Verified the '${termString}' term, which has type '${typeName}'.`, termNode);
   }
 
   return termVerified;
@@ -149,6 +157,10 @@ export default function verifyTerm(termNode, types, context) {
 export function verifyTermAgainstConstructors(termNode, types, context) {
   let termVerifiedAgainstConstructors = false;
 
+  const termString = context.nodeAsString(termNode);
+
+  context.trace(`Verifying the '${termString}' term against constructors...`, termNode);
+
   const constructors = context.getConstructors(),
         constructor = constructors.find((constructor) => {
           const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
@@ -170,6 +182,11 @@ export function verifyTermAgainstConstructors(termNode, types, context) {
 }
 
 export function verifyTermAgainstConstructor(termNode, constructor, context) {
+  const termString = context.nodeAsString(termNode),
+        constructorString = constructor.getString();
+
+  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+
   const constructorTermNode = constructor.getTermNode(),
         nonTerminalNNdeA = termNode,  ///
         nonTerminalNodeB = constructorTermNode,  ///
@@ -182,6 +199,10 @@ export function verifyTermAgainstConstructor(termNode, constructor, context) {
 export function verifyTermAsVariable(termNode, variables, context) {
   let termVerifiedAsVariable = false;
 
+  const termString = context.nodeAsString(termNode);
+
+  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {

package/src/verify/termAsConstructor.js

@@ -38,7 +38,8 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
   }
 
   if (termVerifiedAsConstructor) {
-    const constructor = Constructor.fromTermNodeAndType(termNode, type);
+    const tokens = fileContext.getTokens(),
+          constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
 
     fileContext.addConstructor(constructor);
   }