occam-verify-cli 1.0.852 → 1.0.857

package/src/element/conclusion.js

@@ -81,10 +81,9 @@ export default define(class Conclusion extends Element {
   validateStatement(context) {
     let statementValidates = false;
 
-    const statementString = this.statement.getString(),
-          conclusionString = this.getString();  ///
+    const conclusionString = this.getString();  ///
 
-    context.trace(`Validating the '${conclusionString}' conclusion's '${statementString}' statement...`);
+    context.trace(`Validating the '${conclusionString}' conclusion's statement...`);
 
     descend((context) => {
       const statement = this.statement.validate(context);
@@ -95,7 +94,7 @@ export default define(class Conclusion extends Element {
     }, context);
 
     if (statementValidates) {
-      context.trace(`...validated the '${conclusionString}' conclusion's '${statementString}' statement.`);
+      context.trace(`...validated the '${conclusionString}' conclusion's statement.`);
     }
 
     return statementValidates;

package/src/element/constructor.js

@@ -82,11 +82,10 @@ export default define(class Constructor extends Element {
   validateTerm(context) {
     let termValidates = false;
 
-    const termString = this.term.getString(),
-          includeType = false,
+    const includeType = false,
           constructorString = this.getString(includeType);
 
-    context.trace(`Validating the '${constructorString}' constructor's '${termString}' term...`);
+    context.trace(`Validating the '${constructorString}' constructor's term...`);
 
     const termValidatesAsConstructor = validateTermAsConstructor(this.term, context);
 
@@ -95,7 +94,7 @@ export default define(class Constructor extends Element {
     }
 
     if (termValidates) {
-      context.debug(`...validated the '${constructorString}' constructor's '${termString}' term.`);
+      context.debug(`...validated the '${constructorString}' constructor's term.`);
     }
 
     return termValidates;

package/src/element/declaration/combinator.js

@@ -49,15 +49,14 @@ export default define(class CombinatorDeclaration extends Declaration {
   validateCombinator(context) {
     let combinatorValidates;
 
-    const combinatorString = this.combinator.getString(),
-          combinatorDeclarationString = this.getString();  ///
+    const combinatorDeclarationString = this.getString();  ///
 
-    context.trace(`Validating the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);
+    context.trace(`Validating the '${combinatorDeclarationString}' combinator declaration's combinator...`);
 
     combinatorValidates = this.combinator.validate(context);
 
     if (combinatorValidates) {
-      context.debug(`...validated the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator.`);
+      context.debug(`...validated the '${combinatorDeclarationString}' combinator declaration's combinator.`);
     }
 
     return combinatorValidates;

package/src/element/declaration/complexType.js

@@ -281,7 +281,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     const propertyString = property.getString(),
           nominalTypeName = property.getNominalTypeName();
 
-    context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`);
+    context.trace(`Verifying the '${propertyString}' property's nominal type name...`);
 
     const typeComparesToNominalTypeName = this.type.compareNominalTypeName(nominalTypeName);
 
@@ -296,7 +296,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     }
 
     if (propertyNominalTypeNameVerifies) {
-      context.debug(`...verifies the '${propertyString}' property's '${nominalTypeName}' nominal type name.`);
+      context.debug(`...verifies the '${propertyString}' property's nominal type name.`);
     }
 
     return propertyNominalTypeNameVerifies;

package/src/element/declaration/constructor.js

@@ -65,10 +65,9 @@ export default define(class ConstructorDeclaration extends Declaration {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeString = this.type.getString(),
-          constructorDeclarationString = this.getString();  ///
+    const constructorDeclarationString = this.getString();  ///
 
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${typeString}' type...`);
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's type...`);
 
     const nominalTypeName = this.type.getNominalTypeName(),
           type = context.findTypeByNominalTypeName(nominalTypeName);
@@ -78,6 +77,8 @@ export default define(class ConstructorDeclaration extends Declaration {
             typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
+        const typeString = this.type.getString();
+
         provisional ?
           context.debug(`The '${typeString}' type is present but not provisional.`) :
             context.debug(`The '${typeString}' type is present but provisional.`);
@@ -87,11 +88,13 @@ export default define(class ConstructorDeclaration extends Declaration {
         typeVerifies = true;
       }
     } else {
+      const typeString = this.type.getString();
+
       context.debug(`The '${typeString}' type is not present.`);
     }
 
     if (typeVerifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${typeString}' type.`);
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);
     }
 
     return typeVerifies;

package/src/element/declaration/metavariable.js

@@ -53,15 +53,14 @@ export default define(class MetavariableDeclaration extends Declaration {
   verifyMetaType(context) {
     let metaTypeVerifies = true;
 
-    const metaTypeString = this.metaType.getString(),
-          metaTypeDeclarationString = this.getString(); ///
+    const metaTypeDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${metaTypeDeclarationString}' metavariable declaration's '${metaTypeString}' metaType...`);
+    context.trace(`Verifying the '${metaTypeDeclarationString}' metavariable declaration's metaType...`);
 
     this.metavariable.setMetaType(this.metaType);
 
     if (metaTypeVerifies) {
-      context.debug(`...verified the '${metaTypeDeclarationString}' metavariable declaration's '${metaTypeString}' metaType.`);
+      context.debug(`...verified the '${metaTypeDeclarationString}' metavariable declaration's metaType.`);
     }
 
     return metaTypeVerifies;
@@ -70,10 +69,9 @@ export default define(class MetavariableDeclaration extends Declaration {
   verifyMetavariable(context) {
     let metavariableVerifies = false;
 
-    const metavariableString = this.metavariable.getString(),
-          metavariableDeclarationString = this.getString(); ///
+    const metavariableDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's '${metavariableString}' metavariable...`);
+    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's metavariable...`);
 
     const metavariableName = this.metavariable.getName(),
           declaredMetavariablePresent = context.isDeclaredMetavariablePresentByMetavariableName(metavariableName);
@@ -85,7 +83,7 @@ export default define(class MetavariableDeclaration extends Declaration {
     }
 
     if (metavariableVerifies) {
-      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration's '${metavariableString}' metavariable.`);
+      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration's metavariable.`);
     }
 
     return metavariableVerifies;

package/src/element/declaration/variable.js

@@ -65,21 +65,24 @@ export default define(class VariableDeclaration extends Declaration {
   verifyType(context) {
     let typeVerifies = false;
 
-    const typeString = this.type.getString(),
-          variableDeclarationString = this.getString(); ///
+    const variableDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${typeString}' type...`);
+    context.trace(`Verifying the '${variableDeclarationString}' variable declaration's type...`);
 
     const nominalTypeName = this.type.getNominalTypeName(),
           type = context.findTypeByNominalTypeName(nominalTypeName),
           typePresent = (type !== null)
 
     if (!typePresent) {
+      const typeString = this.type.getString();
+
       context.debug(`The '${typeString}' type is not present.`);
     } else {
       const typeComparesToProvisional = type.compareProvisional(this.provisional);
 
       if (!typeComparesToProvisional) {
+        const typeString = this.type.getString();
+
         this.provisional ?
           context.debug(`The '${variableDeclarationString}' variable declaration's '${typeString}' type is present but not provisional.`) :
             context.debug(`The '${variableDeclarationString}' variable declaration's '${typeString}' type is present but provisional.`);
@@ -91,7 +94,7 @@ export default define(class VariableDeclaration extends Declaration {
     }
 
     if (typeVerifies) {
-      context.debug(`...verified the '${variableDeclarationString}' variable declaration's '${typeString}' type.`);
+      context.debug(`...verified the '${variableDeclarationString}' variable declaration's type.`);
     }
 
     return typeVerifies;

package/src/element/deduction.js

@@ -81,10 +81,9 @@ export default define(class Deduction extends Element {
   validateStatement(context) {
     let statementValidates = false;
 
-    const statementString = this.statement.getString(),
-          deductionnString = this.getString();  ///
+    const deductionnString = this.getString();  ///
 
-    context.trace(`Validating the '${deductionnString}' deductionn's '${statementString}' statement...`);
+    context.trace(`Validating the '${deductionnString}' deductionn's statement...`);
 
     descend((context) => {
       const statement = this.statement.validate(context);
@@ -95,7 +94,7 @@ export default define(class Deduction extends Element {
     }, context);
 
     if (statementValidates) {
-      context.trace(`...validated the '${deductionnString}' deductionn's '${statementString}' statement.`);
+      context.trace(`...validated the '${deductionnString}' deductionn's statement.`);
     }
 
     return statementValidates;

package/src/element/frame.js

@@ -7,7 +7,6 @@ import { instantiate } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
-import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, lineIndex, assumptions, metavariable) {
@@ -166,51 +165,13 @@ export default define(class Frame extends Element {
     return frame;
   }
 
-  validateWhenStated(context) {
-    let validatesWhenStated = false;
-
-    const frameString = this.getString();  ///
-
-    context.trace(`Validating the '${frameString}' stated frame...`);
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      validatesWhenStated = true;
-    } else {
-      context.debug(`The '${frameString}' stated frame must be singular.`);
-    }
-
-    if (validatesWhenStated) {
-      context.debug(`...validated the '${frameString}' stated frame.`);
-    }
-
-    return validatesWhenStated;
-  }
-
-  validateWhenDerived(context) {
-    let validatesWhenDerived;
-
-    const frameString = this.getString();  ///
-
-    context.trace(`Verifying the '${frameString}' derived frame...`);
-
-    validatesWhenDerived = true;
-
-    if (validatesWhenDerived) {
-      context.debug(`...verified the '${frameString}' derived frame.`);
-    }
-
-    return validatesWhenDerived;
-  }
-
   validateAssumption(assumption, assumptions, context) {
     let assumptionValidates = false;
 
     const frameString = this.getString(), ///
-          assumptionstring = assumption.getString();
+          assumptionString = assumption.getString();
 
-    context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
+    context.trace(`Validating the '${frameString}' frame's '${assumptionString}' assumption.`);
 
     assumption = assumption.validate(context);  ///
 
@@ -221,7 +182,7 @@ export default define(class Frame extends Element {
     }
 
     if (assumptionValidates) {
-      context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
+      context.debug(`...validated the '${frameString}' frame's '${assumptionString}' assumption.`);
     }
 
     return assumptionValidates;
@@ -230,31 +191,24 @@ export default define(class Frame extends Element {
   validateAssumptions(context) {
     let assumptionsValidate;
 
-    const assumptionsLength = this.assumptions.length;
-
-    if (assumptionsLength) {
-      const frameString = this.getString(), ///
-            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
+    const frameString = this.getString();
 
-      context.trace(`Validating the '${frameString}' frame's '${assumptionsString}' assumptions...`);
+    context.trace(`Validating the '${frameString}' frame's assumptions...`);
 
-      const assumptions = [];
+    const assumptions = [];
 
-      assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionValidates = this.validateAssumption(assumption, assumptions, context);
+    assumptionsValidate = this.assumptions.every((assumption) => {
+      const assumptionValidates = this.validateAssumption(assumption, assumptions, context);
 
-        if (assumptionValidates) {
-          return true;
-        }
-      });
+      if (assumptionValidates) {
+        return true;
+      }
+    });
 
-      if (assumptionsValidate) {
-        this.assumptions = assumptions;
+    if (assumptionsValidate) {
+      this.assumptions = assumptions;
 
-        context.debug(`...validated the '${frameString}' frame's '${assumptionsString}' assumptions.`);
-      }
-    } else {
-      assumptionsValidate = true;
+      context.debug(`...validated the '${frameString}' frame's assumptions.`);
     }
 
     return assumptionsValidate;
@@ -266,10 +220,9 @@ export default define(class Frame extends Element {
     if (this.metavariable !== null) {
       metavariableValidates = false;
 
-      const frameString = this.getString(), ///
-            metavariableString = this.metavariable.getString();
+      const frameString = this.getString(); ///
 
-      context.trace(`Validating the '${frameString}' frame's '${metavariableString}' metavariable...`);
+      context.trace(`Validating the '${frameString}' frame's metavariable...`);
 
       const metavariable = this.metavariable.validate(context),
             metaTypeName = FRAME_META_TYPE_NAME,
@@ -277,13 +230,77 @@ export default define(class Frame extends Element {
             metavariableMetaTypeEqualToFrameMetaType = metavariable.isMetaTypeEqualTo(frameMetaType);
 
       if (metavariableMetaTypeEqualToFrameMetaType) {
+        this.metavariable = metavariable; ///
+
         metavariableValidates = true;
       }
+
+      if (metavariableValidates) {
+        context.debug(`...validated the '${frameString}' frame's metavariable.`);
+      }
     }
 
     return metavariableValidates;
   }
 
+  validateWhenStated(context) {
+    let validatesWhenStated = false;
+
+    const frameString = this.getString();  ///
+
+    context.trace(`Validating the '${frameString}' stated frame...`);
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      validatesWhenStated = true;
+    } else {
+      context.debug(`The '${frameString}' stated frame must be singular.`);
+    }
+
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${frameString}' stated frame.`);
+    }
+
+    return validatesWhenStated;
+  }
+
+  validateWhenDerived(context) {
+    let validatesWhenDerived = false;
+
+    const frameString = this.getString();  ///
+
+    context.trace(`Verifying the '${frameString}' derived frame...`);
+
+    if (this.metavariable !== null) {
+      const metavariableNode = this.getMetavariableNode(),
+            declaredJudgements = context.findDeclaredJudgementsByMetavariableNode(metavariableNode),
+            declaredJudgementsLength = declaredJudgements.length;
+
+      if (declaredJudgementsLength > 0) {
+        declaredJudgements.forEach((declaredJudgement) => {
+          const assumption = declaredJudgement.getAssumption();
+
+          this.assumptions.push(assumption);
+        });
+
+        validatesWhenDerived = true;
+      } else {
+        const metavariableString = this.metavariable.getString();
+
+        context.trace(`The '${frameString}' frame's '${metavariableString}' metavariable does not match any declared judgements...`);
+      }
+    } else {
+      validatesWhenDerived = true;
+    }
+
+    if (validatesWhenDerived) {
+      context.debug(`...verified the '${frameString}' derived frame.`);
+    }
+
+    return validatesWhenDerived;
+  }
+
   toJSON() {
     const string = this.getString(),
           lineIndex = this.getLineIndex(),

package/src/element/judgement.js

@@ -132,10 +132,9 @@ export default define(class Judgement extends Element {
   validateFrame(context) {
     let frameValidates = false;
 
-    const frameString = this.frame.getString(),
-          judgementString = this.getString(); ///
+    const judgementString = this.getString(); ///
 
-    context.trace(`Validating the '${judgementString}' judgement's '${frameString}' frame...`);
+    context.trace(`Validating the '${judgementString}' judgement's frame...`);
 
     const frame = this.frame.validate(context);
 
@@ -146,7 +145,7 @@ export default define(class Judgement extends Element {
     }
 
     if (frameValidates) {
-      context.trace(`...validated the '${judgementString}' judgement's '${frameString}' frame.`);
+      context.trace(`...validated the '${judgementString}' judgement's frame.`);
     }
 
     return frameValidates;
@@ -155,10 +154,9 @@ export default define(class Judgement extends Element {
   validateAssumption(context) {
     let assumptionValidates = false;
 
-    const assumptionString = this.assumption.getString(),
-          judgementString = this.getString(); ///
+    const judgementString = this.getString(); ///
 
-    context.trace(`Validating the '${judgementString}' judgement's '${assumptionString}' assumption...`);
+    context.trace(`Validating the '${judgementString}' judgement's assumption...`);
 
     const assumption = this.assumption.validate(context);
 
@@ -169,7 +167,7 @@ export default define(class Judgement extends Element {
     }
 
     if (assumptionValidates) {
-      context.debug(`...validated the '${judgementString}' judgement's '${assumptionString}' assumption.`);
+      context.debug(`...validated the '${judgementString}' judgement's assumption.`);
     }
 
     return assumptionValidates;
@@ -198,36 +196,26 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
-    const metavariableNode = this.getMetavariableNode(),
+    const assumptions = this.getAssumptions(),
           topLevelMetaAssertion = this.getTopLevelMetaAssertion(),
           metaLevelAssumptions = topLevelMetaAssertion.getMetaLevelAssumptions(),
-          declaredJudgements = context.findDeclaredJudgementsByMetavariableNode(metavariableNode);
+          metaLevelAssumptionsUnify = metaLevelAssumptions.every((metaLevelAssumption) => {
+            const metaLevelAssumptionUnifies = assumptions.some((assumption) => {
+              const metaLevelAssumptionUnifies = assumption.unifyMetaLevelAssumption(metaLevelAssumption, context);
 
-    let assumptions;
+              if (metaLevelAssumptionUnifies) {
+                return true;
+              }
+            });
 
-    assumptions = this.getAssumptions();
-
-    assumptions = assumptionsFromDeclaredJudgements(declaredJudgements, assumptions);
-
-    reconcile((context) => {
-      const metaLevelAssumptionsUnify = metaLevelAssumptions.every((metaLevelAssumption) => {
-        const metaLevelAssumptionUnifies = assumptions.some((assumption) => {
-          const metaLevelAssumptionUnifies = assumption.unifyMetaLevelAssumption(metaLevelAssumption, context);
-
-          if (metaLevelAssumptionUnifies) {
-            return true;
-          }
-        });
-
-        if (metaLevelAssumptionUnifies) {
-          return true;
-        }
-      });
+            if (metaLevelAssumptionUnifies) {
+              return true;
+            }
+          });
 
-      if (metaLevelAssumptionsUnify) {
-        validatesWhenDerived = true;
-      }
-    }, context);
+    if (metaLevelAssumptionsUnify) {
+      validatesWhenDerived = true;
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${judgementString}' derived judgement.`);
@@ -299,13 +287,3 @@ function assumptionFromJudgementNode(judgementNode, context) {
 
   return assumption;
 }
-
-function assumptionsFromDeclaredJudgements(declaredJudgements, assumptions = []) {
-  declaredJudgements.map((declaredJudgement) => {
-    const assumption = declaredJudgement.getAssumption();
-
-    assumptions.push(assumption);
-  });
-
-  return assumptions;
-}

package/src/element/label.js

@@ -106,10 +106,9 @@ export default define(class Label extends Element {
   validateMetavariable(context) {
     let metavariableValidates = false;
 
-    const labelString = this.getString(), ///
-          metavariableString = this.metavariable.getString();
+    const labelString = this.getString(); ///
 
-    context.trace(`Validating the '${labelString}' label's '${metavariableString}' metavariable...`);
+    context.trace(`Validating the '${labelString}' label's metavariable...`);
 
     const metavariable = this.metavariable.validate(context);
 
@@ -120,7 +119,7 @@ export default define(class Label extends Element {
     }
 
     if (metavariableValidates) {
-      context.debug(`...validated the '${labelString}' label's '${metavariableString}' metavariable.'`);
+      context.debug(`...validated the '${labelString}' label's metavariable.'`);
     }
 
     return metavariableValidates;