Coverage report for lib/src/argument_list_visitor.dart

// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file

// for details. All rights reserved. Use of this source code is governed by a

// BSD-style license that can be found in the LICENSE file.

library dart_style.src.argument_list_visitor;

import 'dart:math' as math;

import 'package:analyzer/dart/ast/ast.dart';

import 'package:analyzer/dart/ast/token.dart';

import 'chunk.dart';

import 'rule/argument.dart';

import 'rule/rule.dart';

import 'source_visitor.dart';

/// Helper class for [SourceVisitor] that handles visiting and writing an

/// [ArgumentList], including all of the special code needed to handle

/// block-formatted arguments.

class ArgumentListVisitor {

  final SourceVisitor _visitor;

  /// The "(" before the argument list.

  final Token _leftParenthesis;

  /// The ")" after the argument list.

  final Token _rightParenthesis;

  /// All of the arguments, positional, named, and functions, in the argument

  /// list.

  final List<Expression> _allArguments;

  /// The normal arguments preceding any block function arguments.

  final ArgumentSublist _arguments;

  /// The contiguous list of block function arguments, if any.

  ///

  /// Otherwise, this is `null`.

  final List<Expression> _functions;

  /// If there are block function arguments, this is the arguments after them.

  ///

  /// Otherwise, this is `null`.

  final ArgumentSublist _argumentsAfterFunctions;

  /// Returns `true` if there is only a single positional argument.

  /// Whether this argument list has any arguments that should be formatted as

  /// blocks.

  // TODO(rnystrom): Returning true based on collections is non-optimal. It

  // forces a method chain to break into two but the result collection may not

  // actually split which can lead to a method chain that's allowed to break

  // where it shouldn't.

  }

      SourceVisitor visitor,

      Token leftParenthesis,

      Token rightParenthesis,

      List<Expression> arguments) {

    // Look for a single contiguous range of block function arguments.

    var functionsStart;

    var functionsEnd;

        if (functionsStart == null) functionsStart = i;

        // The functions must be one contiguous section.

          functionsStart = null;

          functionsEnd = null;

          break;

        }

      }

    }

    // Edge case: If all of the arguments are named, but they aren't all

    // functions, then don't handle the functions specially. A function with a

    // bunch of named arguments tends to look best when they are all lined up,

    // even the function ones (unless they are all functions).

    //

    // Prefers:

    //

    //     function(

    //         named: () {

    //           something();

    //         },

    //         another: argument);

    //

    // Over:

    //

    //     function(named: () {

    //       something();

    //     },

    //         another: argument);

    if (functionsStart != null &&

      functionsStart = null;

    }

    // Edge case: If all of the function arguments are named and there are

    // other named arguments that are "=>" functions, then don't treat the

    // block-bodied functions specially. In a mixture of the two function

    // styles, it looks cleaner to treat them all like normal expressions so

    // that the named arguments line up.

    if (functionsStart != null &&

        }

        return false;

      }

          functionsStart = null;

          break;

        }

      }

          functionsStart = null;

          break;

        }

      }

    }

    if (functionsStart == null) {

      // No functions, so there is just a single argument list.

          visitor,

          leftParenthesis,

          rightParenthesis,

          arguments,

          null,

          null);

    }

    // Split the arguments into two independent argument lists with the

    // functions in the middle.

        visitor,

        leftParenthesis,

        rightParenthesis,

        arguments,

        functions,

  }

      this._visitor,

      this._leftParenthesis,

      this._rightParenthesis,

      this._allArguments,

      this._arguments,

      this._functions,

      this._argumentsAfterFunctions);

  /// Builds chunks for the argument list.

    // If there is just one positional argument, it tends to look weird to

    // split before it, so try not to.

      // TODO(rnystrom): It might look better to treat the parameter list of the

      // first function as if it were an argument in the preceding argument list

      // instead of just having this little solo split here. That would try to

      // keep the parameter list with other arguments when possible, and, I

      // think, generally look nicer.

      } else {

      }

        // Write the following comma.

        }

      }

    }

  }

  /// Returns `true` if [expression] is a [FunctionExpression] with a non-empty

  /// block body.

    }

    // Allow functions wrapped in dotted method calls like "a.b.c(() { ... })".

    }

    }

    // Allow immediately-invoked functions like "() { ... }()".

      var invocation = expression as FunctionExpressionInvocation;

    }

    // Unwrap parenthesized expressions.

    }

    // Must be a function.

    // With a curly body.

    var function = expression as FunctionExpression;

    // That isn't empty.

  }

  /// Returns `true` if [expression] is a valid method invocation target for

  /// an invocation that wraps a function literal argument.

    // Allow bare function calls.

    if (expression == null) return true;

    // Allow property accesses.

    }

    return false;

  }

}

/// A range of arguments from a complete argument list.

///

/// One of these typically covers all of the arguments in an invocation. But,

/// when an argument list has block functions in the middle, the arguments

/// before and after the functions are treated as separate independent lists.

/// In that case, there will be two of these.

class ArgumentSublist {

  /// The full argument list from the AST.

  final List<Expression> _allArguments;

  /// The positional arguments, in order.

  final List<Expression> _positional;

  /// The named arguments, in order.

  final List<Expression> _named;

  /// Maps each block argument, excluding functions, to the first token for that

  /// argument.

  final Map<Expression, Token> _blocks;

  /// The number of leading block arguments, excluding functions.

  ///

  /// If all arguments are blocks, this counts them.

  final int _leadingBlocks;

  /// The number of trailing blocks arguments.

  ///

  /// If all arguments are blocks, this is zero.

  final int _trailingBlocks;

  /// The rule used to split the bodies of all block arguments.

  Rule _blockRule;

  /// The most recent chunk that split before an argument.

  Chunk _previousSplit;

      List<Expression> allArguments, List<Expression> arguments) {

    // Assumes named arguments follow all positional ones.

    var positional =

    }

    // Count the leading arguments that are blocks.

    var leadingBlocks = 0;

    }

    // Count the trailing arguments that are blocks.

    var trailingBlocks = 0;

      }

    }

    // Blocks must all be a prefix or suffix of the argument list (and not

    // both).

    // Ignore any blocks in the middle of the argument list.

    }

        allArguments, positional, named, blocks, leadingBlocks, trailingBlocks);

  }

      this._blocks, this._leadingBlocks, this._trailingBlocks);

    }

  }

  /// Writes the positional arguments, if any.

    // Allow splitting after "(".

    // Only count the blocks in the positional rule.

    return rule;

  }

  /// Writes the named arguments, if any.

    // Only count the blocks in the named rule.

    // Let the positional args force the named ones to split.

    if (positionalRule != null) {

    }

  }

      SourceVisitor visitor, List<Expression> arguments, ArgumentRule rule) {

    // Split before the first argument.

    // Try to not split the positional arguments.

    }

      // Write the split.

      }

    }

  }

      SourceVisitor visitor, ArgumentRule rule, Expression argument) {

    // If we're about to write a block argument, handle it specially.

      // Tell it to use the rule we've already created.

      // Edge case: Only bump the nesting if there are multiple arguments. This

      // lets us avoid spurious indentation in cases like:

      //

      //     function(function(() {

      //       body;

      //     }));

      // Edge case: Likewise, don't force the argument to split if there is

      // only a single positional one, like:

      //

      //     outer(inner(

      //         longArgument));

    }

    } else {

    }

    }

    // Write the following comma.

    }

  }

  /// If [expression] can be formatted as a block, returns the token that opens

  /// the block, such as a collection's bracket.

  ///

  /// Block-formatted arguments can get special indentation to make them look

  /// more statement-like.

    }

    // TODO(rnystrom): Should we step into parenthesized expressions?

    }

    // Not a collection literal.

    return null;

  }

}