Consistent argument ordering (#126)

* initial commit

* updating positionUtils signatures

* updated bad function call after reorder

src/inspection/activeNode/activeNodeUtils.ts

@@ -31,11 +31,11 @@ import { ActiveNode } from "./activeNode";
 // Sometimes we don't want to shift at all.
 // Nodes that prevent shifting are called anchor nodes.
 export function maybeActiveNode(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
     leafNodeIds: ReadonlyArray<number>,
+    position: Position,
 ): ActiveNode | undefined {
-    const astSearch: AstNodeSearch = positionAstSearch(position, nodeIdMapCollection, leafNodeIds);
+    const astSearch: AstNodeSearch = positionAstSearch(nodeIdMapCollection, leafNodeIds, position);
     const maybeContextSearch: ParseContext.Node | undefined = positionContextSearch(astSearch, nodeIdMapCollection);
 
     let maybeLeaf: TXorNode | undefined;
@@ -59,7 +59,7 @@ export function maybeActiveNode(
     return {
         position,
         ancestry: NodeIdMapIterator.expectAncestry(nodeIdMapCollection, leaf.node.id),
-        maybeIdentifierUnderPosition: maybeIdentifierUnderPosition(position, nodeIdMapCollection, leaf),
+        maybeIdentifierUnderPosition: maybeIdentifierUnderPosition(nodeIdMapCollection, leaf, position),
     };
 }
 
@@ -124,9 +124,9 @@ function isAnchorNode(position: Position, astNode: Ast.TNode): boolean {
 }
 
 function positionAstSearch(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
     leafNodeIds: ReadonlyArray<number>,
+    position: Position,
 ): AstNodeSearch {
     const astNodeById: NodeIdMap.AstNodeById = nodeIdMapCollection.astNodeById;
     let maybeCurrentOnOrBefore: Ast.TNode | undefined;
@@ -245,9 +245,9 @@ function positionContextSearch(
 }
 
 function maybeIdentifierUnderPosition(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
     leaf: TXorNode,
+    position: Position,
 ): Ast.Identifier | Ast.GeneralizedIdentifier | undefined {
     if (leaf.kind !== XorNodeKind.Ast) {
         return undefined;

src/inspection/autocomplete.ts

@@ -24,8 +24,8 @@ export type TriedAutocomplete = Result<Autocomplete, CommonError.CommonError>;
 
 export function tryAutocomplete<S = IParserState>(
     settings: CommonSettings,
-    maybeActiveNode: ActiveNode | undefined,
     nodeIdMapCollection: NodeIdMap.Collection,
+    maybeActiveNode: ActiveNode | undefined,
     maybeParseError: ParseError.ParseError<S> | undefined,
 ): TriedAutocomplete {
     if (maybeActiveNode === undefined) {
@@ -39,7 +39,7 @@ export function tryAutocomplete<S = IParserState>(
         : undefined;
 
     let maybePositionName: string | undefined;
-    if (PositionUtils.isInXorNode(activeNode.position, nodeIdMapCollection, leaf, false, true)) {
+    if (PositionUtils.isInXorNode(nodeIdMapCollection, activeNode.position, leaf, false, true)) {
         if (activeNode.maybeIdentifierUnderPosition !== undefined) {
             maybePositionName = activeNode.maybeIdentifierUnderPosition.literal;
         }

src/inspection/position/positionUtils.ts

@@ -20,8 +20,8 @@ export function isBeforeXorNode(position: Position, xorNode: TXorNode, isBoundIn
 }
 
 export function isInXorNode(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
+    position: Position,
     xorNode: TXorNode,
     isLowerBoundIncluded: boolean,
     isUpperBoundIncluded: boolean,
@@ -32,8 +32,8 @@ export function isInXorNode(
 
         case XorNodeKind.Context:
             return isInContextNode(
-                position,
                 nodeIdMapCollection,
+                position,
                 xorNode.node,
                 isLowerBoundIncluded,
                 isUpperBoundIncluded,
@@ -58,25 +58,25 @@ export function isOnXorNodeStart(position: Position, xorNode: TXorNode): boolean
 }
 
 export function isOnXorNodeEnd(
+    nodeIdMapCollection: NodeIdMap.Collection,
     position: Position,
     xorNode: TXorNode,
-    nodeIdMapCollection: NodeIdMap.Collection,
 ): boolean {
     switch (xorNode.kind) {
         case XorNodeKind.Ast:
             return isOnAstNodeEnd(position, xorNode.node);
 
         case XorNodeKind.Context:
-            return isOnContextNodeEnd(position, xorNode.node, nodeIdMapCollection);
+            return isOnContextNodeEnd(nodeIdMapCollection, position, xorNode.node);
 
         default:
             throw isNever(xorNode);
     }
 }
 
 export function isAfterXorNode(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
+    position: Position,
     xorNode: TXorNode,
     isBoundIncluded: boolean,
 ): boolean {
@@ -85,7 +85,7 @@ export function isAfterXorNode(
             return isAfterAstNode(position, xorNode.node, isBoundIncluded);
 
         case XorNodeKind.Context:
-            return isAfterContextNode(position, nodeIdMapCollection, xorNode.node, isBoundIncluded);
+            return isAfterContextNode(nodeIdMapCollection, position, xorNode.node, isBoundIncluded);
 
         default:
             throw isNever(xorNode);
@@ -107,15 +107,15 @@ export function isBeforeContextNode(
 }
 
 export function isInContextNode(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
+    position: Position,
     contextNode: ParseContext.Node,
     isLowerBoundIncluded: boolean,
     isHigherBoundIncluded: boolean,
 ): boolean {
     return (
         !isBeforeContextNode(position, contextNode, isLowerBoundIncluded) &&
-        !isAfterContextNode(position, nodeIdMapCollection, contextNode, isHigherBoundIncluded)
+        !isAfterContextNode(nodeIdMapCollection, position, contextNode, isHigherBoundIncluded)
     );
 }
 
@@ -126,9 +126,9 @@ export function isOnContextNodeStart(position: Position, contextNode: ParseConte
 }
 
 export function isOnContextNodeEnd(
+    nodeIdMapCollection: NodeIdMap.Collection,
     position: Position,
     contextNode: ParseContext.Node,
-    nodeIdMapCollection: NodeIdMap.Collection,
 ): boolean {
     const maybeLeaf: Ast.TNode | undefined = NodeIdMapUtils.maybeRightMostLeaf(nodeIdMapCollection, contextNode.id);
     if (maybeLeaf === undefined) {
@@ -139,8 +139,8 @@ export function isOnContextNodeEnd(
 }
 
 export function isAfterContextNode(
-    position: Position,
     nodeIdMapCollection: NodeIdMap.Collection,
+    position: Position,
     contextNode: ParseContext.Node,
     isBoundIncluded: boolean,
 ): boolean {

src/task.ts

@@ -56,8 +56,8 @@ export function tryInspection<S = IParserState>(
     triedParse: TriedParse<S>,
     position: Inspection.Position,
 ): TriedInspection {
-    let leafNodeIds: ReadonlyArray<number>;
     let nodeIdMapCollection: NodeIdMap.Collection;
+    let leafNodeIds: ReadonlyArray<number>;
     let maybeParseError: ParseError.ParseError<S> | undefined;
 
     if (ResultUtils.isErr(triedParse)) {
@@ -72,18 +72,18 @@ export function tryInspection<S = IParserState>(
         }
 
         const context: ParseContext.State = triedParse.error.state.contextState;
-        leafNodeIds = context.leafNodeIds;
         nodeIdMapCollection = context.nodeIdMapCollection;
+        leafNodeIds = context.leafNodeIds;
     } else {
         const parseOk: ParseOk<S> = triedParse.value;
-        leafNodeIds = parseOk.leafNodeIds;
         nodeIdMapCollection = parseOk.nodeIdMapCollection;
+        leafNodeIds = parseOk.leafNodeIds;
     }
 
     const maybeActiveNode: undefined | ActiveNode = ActiveNodeUtils.maybeActiveNode(
-        position,
         nodeIdMapCollection,
         leafNodeIds,
+        position,
     );
     if (maybeActiveNode === undefined) {
         throw new CommonError.InvariantError(`${tryInspection.name}: couldn't create ActiveNode`);
@@ -110,8 +110,8 @@ export function tryInspection<S = IParserState>(
 
     const triedAutocomplete: Inspection.TriedAutocomplete = Inspection.tryAutocomplete(
         settings,
-        activeNode,
         nodeIdMapCollection,
+        activeNode,
         maybeParseError,
     );
     if (ResultUtils.isErr(triedAutocomplete)) {

src/test/libraryTest/inspection/autocomplete.ts

@@ -20,14 +20,14 @@ function expectAutocompleteOk<S>(
     maybeParseError: ParseError.ParseError<S> | undefined,
 ): ReadonlyArray<KeywordKind> {
     const maybeActiveNode: undefined | ActiveNode = ActiveNodeUtils.maybeActiveNode(
-        position,
         nodeIdMapCollection,
         leafNodeIds,
+        position,
     );
     const triedInspect: TriedAutocomplete = Inspection.tryAutocomplete(
         settings,
-        maybeActiveNode,
         nodeIdMapCollection,
+        maybeActiveNode,
         maybeParseError,
     );
     if (!ResultUtils.isOk(triedInspect)) {

src/test/libraryTest/inspection/invokeExpression.ts

@@ -18,9 +18,9 @@ function expectInvokeExpressionOk(
     position: Position,
 ): undefined | InspectedInvokeExpression {
     const maybeActiveNode: undefined | ActiveNode = ActiveNodeUtils.maybeActiveNode(
-        position,
         nodeIdMapCollection,
         leafNodeIds,
+        position,
     );
     if (!(maybeActiveNode !== undefined)) {
         throw new Error(`AssertedFailed: maybeActiveNode !== undefined`);

src/test/libraryTest/inspection/scope.ts

@@ -129,9 +129,9 @@ function expectScopeForNodeOk(
     position: Position,
 ): ScopeItemByKey {
     const maybeActiveNode: undefined | ActiveNode = ActiveNodeUtils.maybeActiveNode(
-        position,
         nodeIdMapCollection,
         leafNodeIds,
+        position,
     );
     if (maybeActiveNode === undefined) {
         return new Map();

src/test/libraryTest/inspection/type.ts

@@ -27,9 +27,9 @@ function expectScopeTypeOk(
     position: Position,
 ): ScopeTypeMap {
     const maybeActiveNode: undefined | ActiveNode = ActiveNodeUtils.maybeActiveNode(
-        position,
         nodeIdMapCollection,
         leafNodeIds,
+        position,
     );
     if (!(maybeActiveNode !== undefined)) {
         throw new Error(`AssertedFailed: maybeActiveNode !== undefined`);