nl_tokens: Re - order candidate signatures into the result array . Assumes the result array to be empty . The candidate list orders groups in reverse but within a group signatures are kept in declaration order A nit here is that we reorder only signatures that belong to the same symbol so order how inherited signatures are processed is still preserved . interface A { ( x : string ) : void } interface B extends A { ( x : foo ) : string } let b : B ; b ( foo ) // < - here overloads should be processed as [ ( x : foo ) : string ( x : string ) : void ]
pl_tokens: function reorderCandidates ( signatures , result ) { var lastParent ; var lastSymbol ; var cutoffIndex = 0 ; var index ; var specializedIndex = - 1 ; var spliceIndex ; ts . Debug . assert ( ! result . length ) ; for ( var _i = 0 ; _i < signatures . length ; _i ++ ) { var signature = signatures [ _i ] ; var symbol = signature . declaration && getSymbolOfNode ( signature . declaration ) ; var parent_5 = signature . declaration && signature . declaration . parent ; if ( ! lastSymbol || symbol === lastSymbol ) { if ( lastParent && parent_5 === lastParent ) { index ++ ; } else { lastParent = parent_5 ; index = cutoffIndex ; } } else { // current declaration belongs to a different symbol // set cutoffIndex so re-orderings in the future won't change result set from 0 to cutoffIndex index = cutoffIndex = <mask> . length ; lastParent = parent_5 ; } lastSymbol = symbol ; // specialized signatures always need to be placed before non-specialized signatures regardless // of the cutoff position; see GH#1133 if ( signature . hasStringLiterals ) { specializedIndex ++ ; spliceIndex = specializedIndex ; // The cutoff index always needs to be greater than or equal to the specialized signature index // in order to prevent non-specialized signatures from being added before a specialized // signature. cutoffIndex ++ ; } else { spliceIndex = index ; } result . splice ( spliceIndex , 0 , signature ) ; } }