PhpCsFixer\Tokenizer\Tokens::fromArray PHP Method

    public static function fromArray($array, $saveIndexes = null)
    {
        $tokens = new self(count($array));
        if (null === $saveIndexes || $saveIndexes) {
            foreach ($array as $key => $val) {
                $tokens[$key] = $val;
            }
            return $tokens;
        }
        $index = 0;
        foreach ($array as $val) {
            $tokens[$index++] = $val;
        }
        return $tokens;
    }

 private function getNewOrder(array $uses, Tokens $tokens)
 {
     $indexes = array();
     $originalIndexes = array();
     for ($i = count($uses) - 1; $i >= 0; --$i) {
         $index = $uses[$i];
         $startIndex = $tokens->getTokenNotOfKindSibling($index + 1, 1, array(array(T_WHITESPACE)));
         $endIndex = $tokens->getNextTokenOfKind($startIndex, array(';', array(T_CLOSE_TAG)));
         $previous = $tokens->getPrevMeaningfulToken($endIndex);
         $group = $tokens[$previous]->isGivenKind(CT::T_GROUP_IMPORT_BRACE_CLOSE);
         if ($tokens[$startIndex]->isGivenKind(array(CT::T_CONST_IMPORT))) {
             $type = self::IMPORT_TYPE_CONST;
         } elseif ($tokens[$startIndex]->isGivenKind(array(CT::T_FUNCTION_IMPORT))) {
             $type = self::IMPORT_TYPE_FUNCTION;
         } else {
             $type = self::IMPORT_TYPE_CLASS;
         }
         $namespaceTokens = array();
         $index = $startIndex;
         while ($index <= $endIndex) {
             $token = $tokens[$index];
             if ($index === $endIndex || !$group && $token->equals(',')) {
                 if ($group) {
                     // if group import, sort the items within the group definition
                     // figure out where the list of namespace parts within the group def. starts
                     $namespaceTokensCount = count($namespaceTokens) - 1;
                     $namespace = '';
                     for ($k = 0; $k < $namespaceTokensCount; ++$k) {
                         if ($namespaceTokens[$k]->isGivenKind(CT::T_GROUP_IMPORT_BRACE_OPEN)) {
                             $namespace .= '{';
                             break;
                         }
                         $namespace .= $namespaceTokens[$k]->getContent();
                     }
                     // fetch all parts, split up in an array of strings, move comments to the end
                     $parts = array();
                     for ($k1 = $k + 1; $k1 < $namespaceTokensCount; ++$k1) {
                         $comment = '';
                         $namespacePart = '';
                         for ($k2 = $k1;; ++$k2) {
                             if ($namespaceTokens[$k2]->equalsAny(array(',', array(CT::T_GROUP_IMPORT_BRACE_CLOSE)))) {
                                 break;
                             }
                             if ($namespaceTokens[$k2]->isComment()) {
                                 $comment .= $namespaceTokens[$k2]->getContent();
                                 continue;
                             }
                             $namespacePart .= $namespaceTokens[$k2]->getContent();
                         }
                         $namespacePart = trim($namespacePart);
                         $comment = trim($comment);
                         if ('' !== $comment) {
                             $namespacePart .= ' ' . $comment;
                         }
                         $parts[] = $namespacePart . ', ';
                         $k1 = $k2;
                     }
                     $sortedParts = $parts;
                     sort($parts);
                     // check if the order needs to be updated, otherwise don't touch as we might change valid CS (to other valid CS).
                     if ($sortedParts === $parts) {
                         $namespace = Tokens::fromArray($namespaceTokens)->generateCode();
                     } else {
                         $namespace .= substr(implode('', $parts), 0, -2) . '}';
                     }
                 } else {
                     $namespace = Tokens::fromArray($namespaceTokens)->generateCode();
                 }
                 $indexes[$startIndex] = array('namespace' => $namespace, 'startIndex' => $startIndex, 'endIndex' => $index - 1, 'importType' => $type, 'group' => $group);
                 $originalIndexes[] = $startIndex;
                 if ($index === $endIndex) {
                     break;
                 }
                 $namespaceTokens = array();
                 $nextPartIndex = $tokens->getTokenNotOfKindSibling($index, 1, array(array(','), array(T_WHITESPACE)));
                 $startIndex = $nextPartIndex;
                 $index = $nextPartIndex;
                 continue;
             }
             $namespaceTokens[] = $token;
             ++$index;
         }
     }
     uasort($indexes, 'self::sortingCallBack');
     $index = -1;
     $usesOrder = array();
     // Loop trough the index but use original index order
     foreach ($indexes as $v) {
         $usesOrder[$originalIndexes[++$index]] = $v;
     }
     return $usesOrder;
 }