Completely reimplement/redesign the AST representation of parameters.

Parameters (to methods, initializers, accessors, subscripts, etc) have always been represented
as Pattern's (of a particular sort), stemming from an early design direction that was abandoned.
Being built on top of patterns leads to patterns being overly complicated (e.g. tuple patterns
have to have varargs and default parameters) and make working on parameter lists complicated
and error prone.  This might have been ok in 2015, but there is no way we can live like this in
2016.

Instead of using Patterns, carve out a new ParameterList and Parameter type to represent all the
parameter specific stuff.  This simplifies many things and allows a lot of simplifications.
Unfortunately, I wasn't able to do this very incrementally, so this is a huge patch.  The good
news is that it erases a ton of code, and the technical debt that went with it.  Ignoring test
suite changes, we have:
   77 files changed, 2359 insertions(+), 3221 deletions(-)

This patch also makes a bunch of wierd things dead, but I'll sweep those out in follow-on
patches.

Fixes <rdar://problem/22846558> No code completions in Foo( when Foo has error type
Fixes <rdar://problem/24026538> Slight regression in generated header, which I filed to go with 3a23d75.

Fixes an overloading bug involving default arguments and curried functions (see the diff to
Constraints/diagnostics.swift, which we now correctly accept).

Fixes cases where problems with parameters would get emitted multiple times, e.g. in the
test/Parse/subscripting.swift testcase.

The source range for ParamDecl now includes its type, which permutes some of the IDE / SourceModel tests
(for the better, I think).

Eliminates the bogus "type annotation missing in pattern" error message when a type isn't
specified for a parameter (see test/decl/func/functions.swift).

This now consistently parenthesizes argument lists in function types, which leads to many diffs in the
SILGen tests among others.

This does break the "sibling indentation" test in SourceKit/CodeFormat/indent-sibling.swift, and
I haven't been able to figure it out.  Given that this is experimental functionality anyway,
I'm just XFAILing the test for now.  i'll look at it separately from this mongo diff.

Author: lattner

include/swift/AST/AST.h

@@ -25,6 +25,7 @@
 #include "swift/AST/ExprHandle.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/Parameter.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/Stmt.h"
 #include "swift/AST/Types.h"

include/swift/AST/ASTVisitor.h

@@ -27,6 +27,8 @@
 #include "llvm/Support/ErrorHandling.h"
 
 namespace swift {
+  class ParameterList;
+  struct Parameter;
 
 /// ASTVisitor - This is a simple visitor class for Swift expressions.
 template<typename ImplClass,
@@ -158,6 +160,16 @@ class ASTVisitor {
              A, ::std::forward<Args>(AA)...);                       \
   }
 #include "swift/AST/Attr.def"
+  
+  bool visit(ParameterList *PL) {
+    return static_cast<ImplClass*>(this)->visitParameterList(PL);
+  }
+  bool visit(Parameter &P) {
+    return static_cast<ImplClass*>(this)->visitParameter(P);
+  }
+  
+  bool visitParameterList(ParameterList *PL) { return false; }
+  bool visitParameter(Parameter &P) { return false; }
 };
 
 

include/swift/AST/ASTWalker.h

@@ -25,6 +25,7 @@ class Stmt;
 class Pattern;
 class TypeRepr;
 struct TypeLoc;
+class ParameterList;
 
 /// \brief An abstract class used to traverse an AST.
 class ASTWalker {
@@ -182,6 +183,18 @@ class ASTWalker {
   /// params in an AbstractFunctionDecl.
   virtual bool shouldWalkIntoFunctionGenericParams() { return false; }
 
+  /// walkToParameterListPre - This method is called when first visiting a
+  /// ParameterList, before walking into its parameters.  If it returns false,
+  /// the subtree is skipped.
+  ///
+  virtual bool walkToParameterListPre(ParameterList *PL) { return true; }
+  
+  /// walkToParameterListPost - This method is called after visiting the
+  /// children of a parameter list.  If it returns false, the remaining
+  /// traversal is terminated and returns failure.
+  virtual bool walkToParameterListPost(ParameterList *PL) { return true; }
+ 
+  
 protected:
   ASTWalker() = default;
   ASTWalker(const ASTWalker &) = default;

include/swift/AST/AnyFunctionRef.h

@@ -61,10 +61,10 @@ class AnyFunctionRef {
     getCaptureInfo().getLocalCaptures(Result);
   }
 
-  ArrayRef<Pattern *> getBodyParamPatterns() const {
+  ArrayRef<ParameterList *> getParameterLists() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
-      return AFD->getBodyParamPatterns();
-    return TheFunction.get<AbstractClosureExpr *>()->getParamPatterns();
+      return AFD->getParameterLists();
+    return TheFunction.get<AbstractClosureExpr *>()->getParameterLists();
   }
 
   bool hasType() const {

include/swift/AST/ArchetypeBuilder.h

@@ -289,7 +289,7 @@ class ArchetypeBuilder {
   /// because the type \c Dictionary<K,V> cannot be formed without it.
   ///
   /// \returns true if an error occurred, false otherwise.
-  bool inferRequirements(Pattern *pattern, GenericParamList *genericParams);
+  bool inferRequirements(ParameterList *params,GenericParamList *genericParams);
 
   /// Finalize the set of requirements, performing any remaining checking
   /// required before generating archetypes.