occam-verify-cli 1.0.983 → 1.0.985

package/src/element/typePrefix.js

@@ -1,113 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiate } from "../utilities/context";
-import { instantiateTypePrefix } from "../process/instantiate";
-import { nameFromTypePrefixNode } from "../utilities/element";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class TypePrefix extends Element {
-  constructor(context, string, node, breakPoint, name) {
-    super(context, string, node, breakPoint);
-
-    this.name = name;
-  }
-
-  getName() {
-    return this.name;
-  }
-
-  getTypePrefixNode() {
-    const node = this.getNode(),
-          typePrefixNode = node;  ///
-
-    return typePrefixNode;
-  }
-
-  getPrefixName() {
-    const prefixName = this.name;  ///
-
-    return prefixName;
-  }
-
-  compareTypePrefixName(typePrefixName) {
-    const comparesToTypePrefixName = (this.name === typePrefixName);
-
-    return comparesToTypePrefixName;
-  }
-
-  verify(context) {
-    let verifies = false;
-
-    const typePrefixString = this.getString();  ///
-
-    context.trace(`Verifying the '${typePrefixString}' type prefix...`);
-
-    const typePrefix = context.getTypePrefix();
-
-    if (typePrefix === null) {
-      const typePrefixName = this.name, ///
-            typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
-
-      if (!typePrefixPresent) {
-        const nominalTypeName = typePrefixName,  ///
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (!typePresent) {
-          verifies = true;
-        } else {
-          context.debug(`The '${typePrefixString}' type is already present.`);
-        }
-      } else {
-        context.debug(`The '${typePrefixString}' type prefix is already present.`);
-      }
-    } else {
-      context.trace(`The package already has a '${typePrefixString}' type prefix.`);
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${typePrefixString}' type prefix.`);
-    }
-
-    return verifies;
-  }
-
-  static name = "TypePrefix";
-
-  toJSON() {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    return json;
-  }
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            typePrefixNode = instantiateTypePrefix(string, context),
-            node = typePrefixNode, ///
-            breakPoint = breakPointFromJSON(json),
-            name = nameFromTypePrefixNode(typePrefixNode, context);
-
-      context = null; ///
-
-      const typePrefix = new TypePrefix(context, string, node, breakPoint, name);
-
-      return typePrefix;
-    }, context);
-  }
-});

package/src/element/variable.js

@@ -1,259 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import elements from "../elements";
-
-import { define } from "../elements";
-import { instantiate } from "../utilities/context";
-import { instantiateVariable } from "../process/instantiate";
-import { provisionallyStringFromProvisional } from "../utilities/string";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { variableFromTermNode, identifierFromVariableNode } from "../utilities/element";
-import { typeFromJSON, typeToTypeJSON, provisionalFromJSON, provisionalToProvisionalJSON } from "../utilities/json";
-
-export default define(class Variable extends Element {
-  constructor(context, string, node, breakPoint, type, identifier, provisional) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.identifier = identifier;
-    this.provisional = provisional;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getIdentifier() {
-    return this.identifier;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  setType(type) {
-    this.type = type;
-  }
-
-  setProvisional(provisional) {
-    this.provisional = provisional;
-  }
-
-  getVariableNode() {
-    const node = this.getNode(),
-          variableNode = node;  //
-
-    return variableNode;
-  }
-
-  getTypeString() { return this.type.getString(); }
-
-  isEstablished() {
-    const provisional = this.isProvisional(),
-          established = !provisional;
-
-    return established;
-  }
-
-  isIdentifierEqualTo(identifier) {
-    const identifierEqualTo = (this.identifier === identifier);
-
-    return identifierEqualTo;
-  }
-
-  compareVariable(variable) {
-    const variableIdentifier = variable.getIdentifier(),
-          comparesToVariable = (this.identifier === variableIdentifier);
-
-    return comparesToVariable;
-  }
-
-  compareParamter(parameter) {
-    const identifier = parameter.getIdentifier(),
-          identifierEqualTo = this.isIdentifierEqualTo(identifier),
-          comparesToParamter = identifierEqualTo; ///
-
-    return comparesToParamter;
-  }
-
-  compareVariableIdentifier(variableIdentifier) {
-    const identifier = variableIdentifier, ///
-          identifierEqualTo = this.isIdentifierEqualTo(identifier),
-          comparesToVariableIdentifier = identifierEqualTo; ///
-
-    return comparesToVariableIdentifier;
-  }
-
-  validate(context) {
-    let variable = null;
-
-    const variableString = this.getString(); ///
-
-    context.trace(`Validating the '${variableString}' variable...`);
-
-    let validates = false;
-
-    const variableIdentifier = this.identifier, ///
-          declaredVariable = context.findDeclaredVariableByVariableIdentifier(variableIdentifier);
-
-    if (declaredVariable !== null) {
-      const type = declaredVariable.getType(),
-            typeString = type.getString(),
-            provisional = declaredVariable.isProvisional(),
-            variableString = this.getString(),  ///
-            provisinallyString = provisionallyStringFromProvisional(provisional);
-
-      context.trace(`Setting the '${variableString}' variable's type to the '${typeString}' type${provisinallyString}.`);
-
-      this.type = type;
-
-      this.provisional = provisional;
-
-      variable = this;
-
-      validates = true;
-    } else {
-      context.debug(`The '${variableString}' variable is not present.`);
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${variableString}' variable.`);
-    }
-
-    return variable;
-  }
-
-  unifyTerm(term, generalContext, specificContext) {
-    let termUnifies = false;
-
-    const context = specificContext,  ///
-          termString = term.getString(),
-          variableString = this.getString(); ///
-
-    context.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
-
-    const variable = this,  ///
-          termVariableUnifies = this.unifyTermVariable(term, generalContext, specificContext);
-
-    if (termVariableUnifies) {
-      termUnifies = true;
-    } else {
-      const variableNode = variable.getNode(),
-            derivedSubstitution = context.findDerivedSubstitutionByVariableNode(variableNode);
-
-      if (derivedSubstitution !== null) {
-        const derivedSubstitutionTermComparesToTerm = derivedSubstitution.compareTerm(term, context);
-
-        if (derivedSubstitutionTermComparesToTerm) {
-          const derivedSubstitutionString = derivedSubstitution.getString();
-
-          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
-
-          termUnifies = true;
-        }
-      } else {
-        const { TermSubstitution } = elements;
-
-        let termSubstitution;
-
-        termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, generalContext, specificContext);
-
-        termSubstitution = termSubstitution.validate(context);  ///
-
-        const derivedSubstitution = termSubstitution;  ///
-
-        context.addDerivedSubstitution(derivedSubstitution);
-
-        termUnifies = true;
-      }
-    }
-
-    if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
-    }
-
-    return termUnifies;
-  }
-
-  unifyTermVariable(term, generalContext, specificContext) {
-    let termVariableUnifies = false;
-
-    const context = specificContext,  ///
-          termString = term.getString(),
-          variableString = this.getString();  ///
-
-    context.trace(`Unifying the '${termString}' term's variable with the '${variableString}' variable...`);
-
-    const generalContextFilePath = generalContext.getFilePath(),
-          specificContextFilePath = specificContext.getFilePath();
-
-    if (generalContextFilePath === specificContextFilePath) {
-      const variableNode = this.getVariableNode(),  ///
-            variableNodeMatches = term.matchVariableNode(variableNode);
-
-      if (variableNodeMatches) {
-        termVariableUnifies = true;
-      }
-    }
-
-    if (termVariableUnifies) {
-      context.debug(`...unified the '${termString}' term's variable with the '${variableString}' variable.`);
-    }
-
-    return termVariableUnifies;
-  }
-
-  toJSON() {
-    const typeJSON = typeToTypeJSON(this.type),
-          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
-          string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const type = typeJSON,  ///
-          provisional = provisionalJSON,  ///
-          json = {
-            string,
-            breakPoint,
-            type,
-            provisional
-          };
-
-    return json;
-  }
-
-  static name = "Variable";
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            variableNode = instantiateVariable(string, context),
-            node = variableNode,  ///
-            breakPoint = breakPointFromJSON(json),
-            type = typeFromJSON(json, context),
-            identifier = identifierFromVariableNode(variableNode, context),
-            provisional = provisionalFromJSON(json, context);
-
-      context = null;
-
-      const variable = new Variable(context, string, node, breakPoint, type, identifier, provisional);
-
-      return variable;
-    }, context);
-  }
-
-  static fromTerm(term, context) {
-    const termNode = term.getNode(),
-          variable = variableFromTermNode(termNode, context);
-
-    return variable;
-  }
-});

package/src/elements.js

@@ -1,13 +0,0 @@
-"use strict";
-
-const elements = {};
-
-export function define(Element) {
-  const { name } = Element;
-
-  elements[name] = Element;
-
-  return Element;
-}
-
-export default elements;

package/src/metaTypeNames.js

@@ -1,5 +0,0 @@
-"use strict";
-
-export const FRAME_META_TYPE_NAME = "Frame";
-export const REFERENCE_META_TYPE_NAME = "Reference";
-export const STATEMENT_META_TYPE_NAME = "Statement";

package/src/metaTypes.js

@@ -1,71 +0,0 @@
-"use strict";
-
-import elements from "./elements";
-
-import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
-
-let frameMetaType = null,
-    referenceMetaType = null,
-    statementMetaType = null;
-
-export function getMetaTypes() {
-  const frameMetaType = frameMetaTypeFromNothing(),
-        referenceMetaType = referenceMetaTypeFromNothing(),
-        statementMetaType = statementMetaTypeFromNothing(),
-        metaTypes = [
-          frameMetaType,
-          referenceMetaType,
-          statementMetaType
-        ];
-
-  return metaTypes;
-}
-
-export function findMetaTypeByMetaTypeName(metaTypeName) {
-  const metaTypes = getMetaTypes(),
-        metaType = metaTypes.find((metaType) => {
-          const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
-
-          if (metaTypeComparesToMetaTypeName) {
-            return true;
-          }
-        }) || null;
-
-  return metaType;
-}
-
-function frameMetaTypeFromNothing() {
-  if (frameMetaType === null) {
-    const { MetaType } = elements,
-          name = FRAME_META_TYPE_NAME,  ///
-          context = null;
-
-    frameMetaType = MetaType.fromName(name, context);
-  }
-
-  return frameMetaType;
-}
-
-function statementMetaTypeFromNothing() {
-  if (statementMetaType === null) {
-    const { MetaType } = elements,
-          name = STATEMENT_META_TYPE_NAME,  ///
-          context = null;
-
-    statementMetaType = MetaType.fromName(name, context);
-  }
-
-  return statementMetaType;
-}
-
-function referenceMetaTypeFromNothing() {
-  if (referenceMetaType === null) {
-    const { MetaType } = elements,
-          name = REFERENCE_META_TYPE_NAME,  ///
-          context = null;
-
-    referenceMetaType = MetaType.fromName(name, context);
-  }
-
-  return referenceMetaType;
-}

package/src/node/argument.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
-
-export default class ArgumentNode extends NonTerminalNode {
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getTypeNode() {
-    const ruleName = TYPE_RULE_NAME,
-          typeNode = this.getNodeByRuleName(ruleName);
-
-    return typeNode;
-  }
-
-  getSingularTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          singularTermNode = this.getSingularNodeByRuleName(ruleName);
-
-    return singularTermNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ArgumentNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/contained.js

@@ -1,53 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { MISSING } from "../../constants";
-import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
-
-export default class ContainedAssertionNode extends AssertionNode {
-  isNegated() {
-    let negated = false;
-
-    this.someChildNode((childNode) => {
-      const childNodeTerminalNode = childNode.isTerminalNode();
-
-      if (childNodeTerminalNode) {
-        const terminalNode = childNode, ///
-              content = terminalNode.getContent(),
-              contentMessing = (content === MISSING);
-
-        if (contentMessing) {
-          negated = true;
-
-          return true;
-        }
-      }
-    });
-
-    return negated;
-  }
-
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          frameNode = this.getNodeByRuleName(ruleName);
-
-    return frameNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/defined.js

@@ -1,46 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { UNDEFINED } from "../../constants";
-import { FRAME_RULE_NAME, TERM_RULE_NAME } from "../../ruleNames";
-
-export default class DefinedAssertionNode extends AssertionNode {
-  isNegated() {
-    let negated = false;
-
-    this.someChildNode((childNode) => {
-      const childNodeTerminalNode = childNode.isTerminalNode();
-
-      if (childNodeTerminalNode) {
-        const terminalNode = childNode, ///
-              content = terminalNode.getContent(),
-              contentUndefined = (content === UNDEFINED);
-
-        if (contentUndefined) {
-          negated = true;
-
-          return true;
-        }
-      }
-    });
-
-    return negated;
-  }
-
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          frameNode = this.getNodeByRuleName(ruleName);
-
-    return frameNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(DefinedAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/property.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { TERM_RULE_NAME, FRAME_RULE_NAME, PROPERTY_RELATION_RULE_NAME } from "../../ruleNames";
-
-export default class PropertyAssertionNode extends AssertionNode {
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          propertyRelationNode = this.getNodeByRuleName(ruleName);
-
-    return propertyRelationNode;
-  }
-
-  getPropertyRelationNode() {
-    const ruleName = PROPERTY_RELATION_RULE_NAME,
-          propertyRelationNode = this.getNodeByRuleName(ruleName);
-
-    return propertyRelationNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/signature.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { SIGNATURE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
-
-export default class SignatureAssertionNode extends AssertionNode {
-  getSignatureNode() {
-    const ruleName = SIGNATURE_RULE_NAME,
-          signatureNode = this.getNodeByRuleName(ruleName);
-
-    return signatureNode;
-  }
-
-  getMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNode = this.getNodeByRuleName(ruleName);
-
-    return metavariableNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SignatureAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/subproof.js

@@ -1,16 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { STATEMENT_RULE_NAME } from "../../ruleNames";
-
-export default class SubproofAssertionNode extends AssertionNode {
-  getStatementNodes() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNodes = this.getNodesByRuleName(ruleName);
-
-    return statementNodes;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion/type.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import AssertionNode from "../../node/assertion";
-
-import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
-
-export default class TypeAssertionNode extends AssertionNode {
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getTypeNode() {
-    const ruleName = TYPE_RULE_NAME,
-          typeNode = this.getNodeByRuleName(ruleName);
-
-    return typeNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeAssertionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/assertion.js

@@ -1,7 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-export default class AssertionNode extends NonTerminalNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
-}