occam-verify-cli 1.0.642 → 1.0.649

package/src/node/declaration/simpleType.js

@@ -6,13 +6,6 @@ import { PROVISIONAL } from "../../constants";
 import { TYPE_RULE_NAME, TYPES_RULE_NAME } from "../../ruleNames";
 
 export default class SimpleTypeDeclarationNode extends DeclarationNode {
-  isPrefixed() {
-    const typeNode = this.getTypeNode(),
-          prefixed = typeNode.isPrefixed();
-
-    return prefixed;
-  }
-
   isProvisional() {
     let provisional = false;
 

package/src/process/assign.js

@@ -55,32 +55,24 @@ export function rightVariableAssignmentFromEquality(equality, context) {
 }
 
 export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
+  let variableAssignment = null;
 
-  debugger
+  const term = typeAssertion.getTerm(),
+        termSingular = term.isSingular();
 
-  // const { Type, Variable } = elements,
-  //   termNode = this.term.getNode();
-  //
-  // let type,
-  //   provisional;
-  //
-  // provisional = this.type.isProvisional();
-  //
-  // if (!provisional) {
-  //   type = this.type;
-  // } else {
-  //   provisional = false;
-  //
-  //   type = Type.fromTypeAndProvisional(this.type, provisional);
-  // }
-  //
-  // const singularVariableNode = termNode.getSingularVariableNode();
-  //
-  // if (singularVariableNode !== null) {
-  //   const variableNode = singularVariableNode,  ///
-  //     variable = Variable.fromVariableNodeAndType(variableNode, type, context),
-  //     variableAssignment = variableAssignmentFromVariable(variable),
+  if (termSingular) {
+    const variableIdentifier = term.getVariableIdentifier(),
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+    if (variable !== null) {
+      const type = typeAssertion.getType(),
+            variableNode = variable.getNode();
 
+      variableAssignment = variableAssignmentFromVariableNodeAndType(variableNode, type, context);
+    }
+  }
+
+  return variableAssignment;
 }
 
 export function variableAssignmentFromPrepertyAssertion(propertyAssertion, context) {

package/src/process/unify.js

@@ -145,6 +145,22 @@ class MetaLevelPass extends ZipPass {
 }
 
 class CombinatorPass extends ZipPass {
+  run(combinatorStatementNode, statementNode, stated, generalContext, specificContext) {
+    let success = false;
+
+    const specificnonTerminalNode = statementNode,  ///
+          generalcnonTerminalNode = combinatorStatementNode,  ///
+          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
+          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalcChildNodes, specificChildNodes, stated, generalContext, specificContext);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       generalNodeQuery: metaTypeNodeQuery,
@@ -236,6 +252,22 @@ class CombinatorPass extends ZipPass {
 }
 
 class ConstructorPass extends ZipPass {
+  run(constructorTermNode, termNode, generalContext, specificContext) {
+    let success = false;
+
+    const specificnonTerminalNode = termNode,  ///
+          generalcnonTerminalNode = constructorTermNode,  ///
+          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
+          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalcChildNodes, specificChildNodes, generalContext, specificContext);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       generalNodeQuery: typeNodeQuery,

package/src/process/verify.js

@@ -288,6 +288,20 @@ class TopLevelPass extends AsyncPass {
 }
 
 class ConbinatorPass extends SimplePass {
+  run(statementNode, context) {
+    let success = false;
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       nodeQuery: statementNodeQuery,
@@ -350,6 +364,20 @@ class ConbinatorPass extends SimplePass {
 }
 
 class ConstructorPass extends SimplePass {
+  run(termNode, context) {
+    let success = false;
+
+    const nonTerminalNode = termNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
   static maps = [
     {
       nodeQuery: termNodeQuery,
@@ -408,26 +436,28 @@ export async function verifyFile(fileNode, context) {
   return fileVerifies;
 }
 
-export function verifyCombinator(combintot) {
-  const context = combintot.getContext(),
-        statement = combintot.getStatement(),
-        statementNode = statement.getNode(),
-        nonTerminalNode = statementNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        descended = combinatorPass.descend(childNodes, context),
-        combinatorVerifies = descended;  ///
+export function verifyTermAsConstructor(term, context) {
+  let termVerifiesAsConstructor = false;
 
-  return combinatorVerifies;
+  const termNode = term.getNode(),
+        success = constructorPass.run(termNode, context);
+
+  if (success) {
+    termVerifiesAsConstructor = true;
+  }
+
+  return termVerifiesAsConstructor;
 }
 
-export function verifyConstrcctor(constructor) {
-  const context = constructor.getContext(),
-        term = constructor.getStatement(),
-        termNode = term.getNode(),
-        nonTerminalNode = termNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        descended = constructorPass.descend(childNodes, context),
-        constrcctorVerifies = descended;  ///
+export function verifyStatementAsCombinator(statement, context) {
+  let statementVerifiesAsCombinator = false;
+
+  const statementNode = statement.getNode(),
+        success = combinatorPass.run(statementNode, context);
+
+  if (success) {
+    statementVerifiesAsCombinator = true;
+  }
 
-  return constrcctorVerifies;
+  return statementVerifiesAsCombinator;
 }

package/src/utilities/element.js

@@ -741,9 +741,9 @@ export function simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDec
         node = simpleTypeDeclarationNode, ///
         string = context.nodeAsString(node),
         type = typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-        prefixed = prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
         superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-        simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, node, type, prefixed, superTypes);
+        provisional = provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
+        simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, node, type, superTypes, provisional);
 
   return simpleTypeDeclaration;
 }
@@ -789,8 +789,9 @@ export function complexTypeDeclarationFromComplexTypeDeclarationNode(complexType
         node = complexTypeDeclarationNode,  ///
         string = context.nodeAsString(node),
         type = typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        prefixed = prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-        complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, type, prefixed);
+        superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        provisional = provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
+        complexTypeDeclaration = new ComplexTypeDeclaration(context, string, node, type, superTypes, provisional);
 
   return complexTypeDeclaration;
 }
@@ -1584,12 +1585,6 @@ export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, co
   return suppositions;
 }
 
-export function prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  const prefixed = simpleTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
 export function resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context) {
   const resolved = statementSubstitutionNode.isResolved();
 
@@ -1603,12 +1598,6 @@ export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode,
   return deduction;
 }
 
-export function prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const prefixed = complexTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
 export function procedureReferenceFromProcedureCallNode(procedureCallNode, context) {
   const procedureReferenceNode = procedureCallNode.getProcedureReferenceNode(),
         procedureReference = procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context);
@@ -1658,12 +1647,26 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
-export function provisionalFromConstructorDeclarationNode(constructorDeclarationNode, context) {
-  const provisional = constructorDeclarationNode.isProvisional();
+export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+  const provisional = simpleTypeDeclarationNode.isProvisional();
 
   return provisional;
 }
 
+export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  let superTypes = [];
+
+  const typesNode = complexTypeDeclarationNode.getTypesNode();
+
+  if (typesNode !== null) {
+    const types = typesFromTypesNode(typesNode, context);
+
+    superTypes = types; ///
+  }
+
+  return superTypes;
+}
+
 export function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode(),
         replacementFrame = frameFromFrameNode(replacementFrameNode, context);
@@ -1700,6 +1703,18 @@ export function constructorFromConstructorDeclarationNode(constructorDeclaration
   return constructor;
 }
 
+export function provisionalFromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  const provisional = constructorDeclarationNode.isProvisional();
+
+  return provisional;
+}
+
+export function provisionalFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const provisional = complexTypeDeclarationNode.isProvisional();
+
+  return provisional;
+}
+
 export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   const metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
         metavariable = metavariableFromMetavariableNode(metavariableNode, context);

package/src/utilities/fileContext.js

@@ -11,7 +11,7 @@ export function FileContextFromFilePath(filePath) {
   let FileContext = null;
 
   const filePathFurtleFilePath = isFilePathFurtleFilePath(filePath),
-    filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+        filePathNominalFilePath = isFilePathNominalFilePath(filePath);
 
   if (filePathFurtleFilePath) {
     FileContext = FurtleFileContext;  ///

package/src/utilities/json.js

@@ -544,6 +544,7 @@ export function metaTypeToMetaTypeJSON(metaType) {
   const metaTypeJSON = (metaType !== null) ?
                          metaType.toJSON() :
                            null;
+
   return metaTypeJSON;
 }
 

package/src/utilities/type.js

@@ -10,10 +10,9 @@ export function baseTypeFromNothing() {
   if (baseType === null) {
     const { Type } = elements,
           name = BASE_TYPE_SYMBOL,  ///
-          context = null,
-          provisional = false;
+          context = null;
 
-    baseType = Type.fromNameAndProvisional(name, provisional, context);
+    baseType = Type.fromName(name, context);
   }
 
   return baseType;