occam-verify-cli 1.0.166 → 1.0.169

package/src/node/derivation.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class DerivationNode extends Node {}

package/src/node/equality.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class EqualityNode extends Node {}

package/src/node/error.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ErrorNode extends Node {}

package/src/node/frame.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class FrameNode extends Node {}

package/src/node/judgement.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class JudgementNode extends Node {}

package/src/node/label.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class LabelNode extends Node {}

package/src/node/lemma.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class LemmaNode extends Node {}

package/src/node/metaLemma.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class MetaLemmaNode extends Node {}

package/src/node/metaType.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class MetaTypeNode extends Node {}

package/src/node/metatheorem.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class MetatheoremNode extends Node {}

package/src/node/metavariable.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class MetavariableNode extends Node {}

package/src/node/parameter.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ParameterNode extends Node {}

package/src/node/premise.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class PremiseNode extends Node {}

package/src/node/procedureCall.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ProcedureCallNode extends Node {}

package/src/node/proof.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ProofNode extends Node {}

package/src/node/property.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class PropertyNode extends Node {}

package/src/node/propertyRelation.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class PropertyRelationNode extends Node {}

package/src/node/reference.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class ReferenceNode extends Node {}

package/src/node/rule.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class RuleNode extends Node {}

package/src/node/statement.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class StatementNode extends Node {}

package/src/node/step.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class StepNode extends Node {}

package/src/node/subDerivation.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class SubDerivationNode extends Node {}

package/src/node/subproof.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class SubproofNode extends Node {}

package/src/node/supposition.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class SuppositionNode extends Node {}

package/src/node/term.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class TermNode extends Node {}

package/src/node/theorem.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class TheoremNode extends Node {}

package/src/node/topLevelAssertion.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class TopLevelAssertionNode extends Node {}

package/src/node/topLevelMetaAssertion.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class TopLevelMetaAssertionNode extends Node {}

package/src/node/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class TypeNode extends Node {}

package/src/node/variable.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import Node from "../node";
+
+export default class VariableNode extends Node {}

package/src/node.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-parsers";
+
+export default class Node extends NonTerminalNode {}

package/src/nodeMap.js

@@ -0,0 +1,146 @@
+"use strict";
+
+import TermNode from "./node/term"
+import TypeNode from "./node/type"
+import RuleNode from "./node/rule"
+import StepNode from "./node/step"
+import ErrorNode from "./node/error"
+import FrameNode from "./node/frame"
+import AxiomNode from "./node/axiom"
+import LabelNode from "./node/label"
+import LemmaNode from "./node/lemma"
+import ProofNode from "./node/proof"
+import PremiseNode from "./node/premise"
+import TheoremNode from "./node/theorem"
+import SubproofNode from "./node/subproof"
+import PropertyNode from "./node/property"
+import MetaTypeNode from "./node/metaType"
+import EqualityNode from "./node/equality"
+import StatementNode from "./node/statement"
+import ReferenceNode from "./node/reference"
+import DeductionNode from "./node/deduction"
+import JudgementNode from "./node/judgement"
+import MetaLemmaNode from "./node/metaLemma"
+import ParameterNode from "./node/parameter"
+import DerivationNode from "./node/derivation"
+import CombinatorNode from "./node/combinator"
+import ConclusionNode from "./node/conclusion"
+import ConjectureNode from "./node/conjecture"
+import SuppositionNode from "./node/supposition"
+import ConstructorNode from "./node/constructor"
+import DeclarationNode from "./node/declaration"
+import MetatheoremNode from "./node/metatheorem"
+import MetavariableNode from "./node/metavariable"
+import ProcedureCallNode from "./node/procedureCall"
+import SubDerivationNode from "./node/subDerivation"
+import TypeAssertionNode from "./node/assertion/type";
+import typeDeclarationNode from "./node/declaration/type";
+import DefinedAssertionNode from "./node/assertion/defined";
+import PropertyRelationNode from "./node/propertyRelation"
+import PropertyAssertionNode from "./node/assertion/property";
+import SubproofAssertionNode from "./node/assertion/subproof";
+import ContainedAssertionNode from "./node/assertion/contained";
+import SatisfiesAssertionNode from "./node/assertion/satisfies";
+import variableDeclarationNode from "./node/declaration/variable";
+import combinatorDeclarationNode from "./node/declaration/combinator";
+import complexTypeDeclarationNode from "./node/declaration/complexType";
+import constructorDeclarationNode from "./node/declaration/constructor";
+import metavariableDeclarationNode from "./node/declaration/metavariable";
+
+import { RULE_RULE_NAME,
+         STEP_RULE_NAME,
+         TERM_RULE_NAME,
+         TYPE_RULE_NAME,
+         PROOF_RULE_NAME,
+         ERROR_RULE_NAME,
+         FRAME_RULE_NAME,
+         AXIOM_RULE_NAME,
+         LABEL_RULE_NAME,
+         LEMMA_RULE_NAME,
+         THEOREM_RULE_NAME,
+         PREMISE_RULE_NAME,
+         SUBPROOF_RULE_NAME,
+         PROPERTY_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         META_TYPE_RULE_NAME,
+         DEDUCTION_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         PARAMETER_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         META_LEMMA_RULE_NAME,
+         DERIVATION_RULE_NAME,
+         COMBINATOR_RULE_NAME,
+         CONCLUSION_RULE_NAME,
+         CONJECTURE_RULE_NAME,
+         CONSTRUCTOR_RULE_NAME,
+         DECLARATION_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
+         METATHEOREM_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         SUB_DERIVATION_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
+         PROCEDURE_CALL_RULE_NAME,
+         TYPE_DECLARATION_RULE_NAME,
+         PROPERTY_RELATION_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
+         VARIABLE_DECLARATION_RULE_NAME,
+         COMBINATOR_DECLARATION_RULE_NAME,
+         CONSTRUCTOR_DECLARATION_RULE_NAME,
+         COMPLEX_TYPE_DECLARATION_RULE_NAME,
+         METAVARIABLE_DECLARATION_RULE_NAME } from "./ruleNames";
+
+const ruleMap = {
+  [RULE_RULE_NAME]: RuleNode,
+  [STEP_RULE_NAME]: StepNode,
+  [TERM_RULE_NAME]: TermNode,
+  [TYPE_RULE_NAME]: TypeNode,
+  [ERROR_RULE_NAME]: ErrorNode,
+  [FRAME_RULE_NAME]: FrameNode,
+  [LABEL_RULE_NAME]: LabelNode,
+  [LEMMA_RULE_NAME]: LemmaNode,
+  [AXIOM_RULE_NAME]: AxiomNode,
+  [PROOF_RULE_NAME]: ProofNode,
+  [THEOREM_RULE_NAME]: TheoremNode,
+  [PREMISE_RULE_NAME]: PremiseNode,
+  [PROPERTY_RULE_NAME]: PropertyNode,
+  [EQUALITY_RULE_NAME]: EqualityNode,
+  [SUBPROOF_RULE_NAME]: SubproofNode,
+  [REFERENCE_RULE_NAME]: ReferenceNode,
+  [JUDGEMENT_RULE_NAME]: JudgementNode,
+  [META_TYPE_RULE_NAME]: MetaTypeNode,
+  [DEDUCTION_RULE_NAME]: DeductionNode,
+  [PARAMETER_RULE_NAME]: ParameterNode,
+  [STATEMENT_RULE_NAME]: StatementNode,
+  [COMBINATOR_RULE_NAME]: CombinatorNode,
+  [CONCLUSION_RULE_NAME]: ConclusionNode,
+  [CONJECTURE_RULE_NAME]: ConjectureNode,
+  [DERIVATION_RULE_NAME]: DerivationNode,
+  [META_LEMMA_RULE_NAME]: MetaLemmaNode,
+  [SUPPOSITION_RULE_NAME]: SuppositionNode,
+  [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
+  [DECLARATION_RULE_NAME]: DeclarationNode,
+  [METATHEOREM_RULE_NAME]: MetatheoremNode,
+  [METAVARIABLE_RULE_NAME]: MetavariableNode,
+  [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,
+  [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
+  [SUB_DERIVATION_RULE_NAME]: SubDerivationNode,
+  [TYPE_DECLARATION_RULE_NAME]: typeDeclarationNode,
+  [PROPERTY_RELATION_RULE_NAME]: PropertyRelationNode,
+  [DEFINED_ASSERTION_RULE_NAME]: DefinedAssertionNode,
+  [SUBPROOF_ASSERTION_RULE_NAME]: SubproofAssertionNode,
+  [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
+  [SATISFIES_ASSERTION_RULE_NAME]: SatisfiesAssertionNode,
+  [CONTAINED_ASSERTION_RULE_NAME]: ContainedAssertionNode,
+  [VARIABLE_DECLARATION_RULE_NAME]: variableDeclarationNode,
+  [COMBINATOR_DECLARATION_RULE_NAME]: combinatorDeclarationNode,
+  [CONSTRUCTOR_DECLARATION_RULE_NAME]: constructorDeclarationNode,
+  [COMPLEX_TYPE_DECLARATION_RULE_NAME]: complexTypeDeclarationNode,
+  [METAVARIABLE_DECLARATION_RULE_NAME]: metavariableDeclarationNode
+};
+
+export default ruleMap;

package/src/nominal/lexer.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { NominalLexer as NominalLexerBase } from "occam-grammars";
+
+export default class NominalLexer extends NominalLexerBase {
+  static fromRules(rules) { return NominalLexerBase.fromRules(NominalLexer, rules); }
+
+  static fromEntries(entries) { return NominalLexerBase.fromEntries(NominalLexer, entries); }
+
+  static fromNothing() { return NominalLexerBase.fromNothing(NominalLexer); }
+}

package/src/nominal/parser.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { NominalParser as NominalParserBase } from "occam-grammars";
+
+import Node from "../node";
+import nodeMap from "../nodeMap";
+
+import { setNonTerminalNodes } from "../utilities/parser";
+
+export default class NominalParser extends NominalParserBase {
+  static fromBNF(bnf) {
+    const markdownParser = NominalParserBase.fromBNF(NominalParser, bnf),
+          DefaultNonTerminalNode = Node;  ///
+
+    setNonTerminalNodes(markdownParser, nodeMap, DefaultNonTerminalNode);
+
+    return markdownParser;
+  }
+
+  static fromRules(rules) {
+    const markdownParser = NominalParserBase.fromRules(NominalParser, rules),
+          DefaultNonTerminalNode = Node;  ///
+
+    setNonTerminalNodes(markdownParser, nodeMap, DefaultNonTerminalNode);
+
+    return markdownParser;
+  }
+
+  static fromNothing() {
+    const markdownParser = NominalParserBase.fromNothing(NominalParser),
+          DefaultNonTerminalNode = Node;  ///
+
+    setNonTerminalNodes(markdownParser, nodeMap, DefaultNonTerminalNode);
+
+    return markdownParser;
+  }
+}

package/src/ruleNames.js

@@ -0,0 +1,48 @@
+"use strict";
+
+export const RULE_RULE_NAME = "rule";
+export const STEP_RULE_NAME = "step";
+export const TERM_RULE_NAME = "term";
+export const TYPE_RULE_NAME = "type";
+export const LABEL_RULE_NAME = "label";
+export const LEMMA_RULE_NAME = "lemma";
+export const AXIOM_RULE_NAME = "axiom";
+export const ERROR_RULE_NAME = "error";
+export const FRAME_RULE_NAME = "frame";
+export const PROOF_RULE_NAME = "proof";
+export const THEOREM_RULE_NAME = "theorem";
+export const PREMISE_RULE_NAME = "premise";
+export const PROPERTY_RULE_NAME = "property";
+export const EQUALITY_RULE_NAME = "equality";
+export const SUBPROOF_RULE_NAME = "subproof";
+export const PARAMETER_RULE_NAME = "parameter";
+export const META_TYPE_RULE_NAME = "metaType";
+export const DEDUCTION_RULE_NAME = "deduction";
+export const JUDGEMENT_RULE_NAME = "judgement";
+export const REFERENCE_RULE_NAME = "reference";
+export const STATEMENT_RULE_NAME = "statement";
+export const COMBINATOR_RULE_NAME = "combinator";
+export const CONCLUSION_RULE_NAME = "conclusion";
+export const CONJECTURE_RULE_NAME = "conjecture";
+export const DERIVATION_RULE_NAME = "derivation";
+export const META_LEMMA_RULE_NAME = "metaLemma";
+export const SUPPOSITION_RULE_NAME = "supposition";
+export const CONSTRUCTOR_RULE_NAME = "constructor";
+export const DECLARATION_RULE_NAME = "declaration";
+export const METATHEOREM_RULE_NAME = "metatheorem";
+export const METAVARIABLE_RULE_NAME = "metavariable";
+export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
+export const SUB_DERIVATION_RULE_NAME = "subDerivation";
+export const TYPE_ASSERTION_RULE_NAME = "typeAssertion";
+export const TYPE_DECLARATION_RULE_NAME = "typeDeclaration";
+export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
+export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
+export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
+export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
+export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
+export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
+export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
+export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
+export const COMPLEX_TYPE_DECLARATION_RULE_NAME = "complexTypeDeclaration";
+export const METAVARIABLE_DECLARATION_RULE_NAME = "metavariableDeclaration";

package/src/utilities/parser.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import { rulesUtilities } from "occam-parsers";
+
+const { rulesFromStartRuleAndRuleMap } = rulesUtilities;
+
+export function setNonTerminalNodes(parser, nodeMap, DefaultNonTerminalNode) {
+  const startRule = parser.getStartRule(),
+        ruleMap = parser.getRuleMap(),
+        rules = rulesFromStartRuleAndRuleMap(startRule, ruleMap);
+
+  rules.forEach((rule) => {
+    const ruleName = rule.getName(),
+          NonTerminalNode = nodeMap[ruleName] || DefaultNonTerminalNode; ///
+
+    rule.setNonTerminalNode(NonTerminalNode);
+  });
+}

package/src/utilities/type.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { objectType } from "../dom/type";
+
+export function superTypesStringFromSuperTypes(superTypes) {
+  const superTypesString = superTypes.reduce((superTypesString, superType) => {
+    if (superType !== objectType) {
+      const superTypeString = superType.getString();
+
+      superTypesString = (superTypesString === null) ?
+                           `'${superTypeString}'` :
+                             `${superTypesString}, '${superTypeString}'`;
+    }
+
+    return superTypesString;
+  }, null);
+
+  return superTypesString;
+}