Substantially rework how SILGen handles bridging as part of laying the

ground work for the syntactic bridging peephole.

- Pass source and dest formal types to the bridging routines in addition
  to the dest lowered type.  The dest lowered type is still necessary
  in order to handle non-standard abstraction patterns for the dest type.

- Change bridging abstraction patterns to store bridged formal types
  instead of the formal type.

- Improve how SIL type lowering deals with import-as-member patterns.

- Fix some AST bugs where inadequate information was being stored in
  various expressions.

- Introduce the idea of a converting SGFContext and use it to regularize
  the existing id-as-Any conversion peephole.

- Improve various places in SILGen to emit directly into contexts.

Author: rjmccall

include/swift/AST/Expr.h

@@ -342,9 +342,9 @@ class alignas(8) Expr {
   class TupleShuffleExprBitfields {
     friend class TupleShuffleExpr;
     unsigned : NumImplicitConversionExprBits;
-    unsigned IsSourceScalar : 1;
+    unsigned TypeImpact : 2;
   };
-  enum { NumTupleShuffleExprBits = NumImplicitConversionExprBits + 1 };
+  enum { NumTupleShuffleExprBits = NumImplicitConversionExprBits + 2 };
   static_assert(NumTupleShuffleExprBits <= 32, "fits in an unsigned");
 
   class ApplyExprBitfields {
@@ -2804,7 +2804,7 @@ class UnevaluatedInstanceExpr : public ImplicitConversionExpr {
 };
 
 /// TupleShuffleExpr - This represents a permutation of a tuple value to a new
-/// tuple type.  The expression's type is known to be a tuple type.
+/// tuple type.
 ///
 /// If hasScalarSource() is true, the subexpression should be treated
 /// as if it were implicitly injected into a single-element tuple
@@ -2825,9 +2825,22 @@ class TupleShuffleExpr : public ImplicitConversionExpr {
     CallerDefaultInitialize = -3
   };
 
-  enum SourceIsScalar_t : bool {
-    SourceIsTuple = false,
-    SourceIsScalar = true
+  enum TypeImpact {
+    /// The source value is a tuple which is destructured and modified to
+    /// create the result, which is a tuple.
+    TupleToTuple,
+
+    /// The source value is a tuple which is destructured and modified to
+    /// create the result, which is a scalar because it has one element and
+    /// no labels.
+    TupleToScalar,
+
+    /// The source value is an individual value (possibly one with tuple
+    /// type) which is inserted into a particular position in the result,
+    /// which is a tuple.
+    ScalarToTuple
+
+    // (TupleShuffleExprs are never created for a scalar-to-scalar conversion.)
   };
 
 private:
@@ -2851,7 +2864,7 @@ class TupleShuffleExpr : public ImplicitConversionExpr {
 
 public:
   TupleShuffleExpr(Expr *subExpr, ArrayRef<int> elementMapping, 
-                   SourceIsScalar_t isSourceScalar,
+                   TypeImpact typeImpact,
                    ConcreteDeclRef defaultArgsOwner,
                    ArrayRef<unsigned> VariadicArgs,
                    Type VarargsArrayTy,
@@ -2862,17 +2875,23 @@ class TupleShuffleExpr : public ImplicitConversionExpr {
       DefaultArgsOwner(defaultArgsOwner), VariadicArgs(VariadicArgs),
       CallerDefaultArgs(CallerDefaultArgs)
   {
-    TupleShuffleExprBits.IsSourceScalar = isSourceScalar;
+    TupleShuffleExprBits.TypeImpact = typeImpact;
   }
 
   ArrayRef<int> getElementMapping() const { return ElementMapping; }
 
-  /// Is the source expression scalar?
-  ///
-  /// This doesn't necessarily mean it's not a tuple; it just means
-  /// that it should be treated as if it were an element of a
-  /// single-element tuple for the purposes of interpreting behavior.
-  bool isSourceScalar() const { return TupleShuffleExprBits.IsSourceScalar; }
+  /// What is the type impact of this shuffle?
+  TypeImpact getTypeImpact() const {
+    return TypeImpact(TupleShuffleExprBits.TypeImpact);
+  }
+
+  bool isSourceScalar() const {
+    return getTypeImpact() == ScalarToTuple;
+  }
+
+  bool isResultScalar() const {
+    return getTypeImpact() == TupleToScalar;
+  }
 
   Type getVarargsArrayType() const {
     assert(!VarargsArrayTy.isNull());

include/swift/AST/ForeignInfo.h

@@ -0,0 +1,34 @@
+//===--- ForeignInfo.h - Declaration import information ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ForeignInfo structure, which includes
+// structural information about how a foreign API's physical type
+// maps into the Swift type system.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_FOREIGN_INFO_H
+#define SWIFT_FOREIGN_INFO_H
+
+#include "swift/AST/ForeignErrorConvention.h"
+#include "swift/AST/Decl.h"
+
+namespace swift {
+
+struct ForeignInfo {
+  ImportAsMemberStatus Self;
+  Optional<ForeignErrorConvention> Error;
+};
+
+} // end namespace swift
+
+#endif

include/swift/AST/Types.h

@@ -2356,6 +2356,17 @@ class AnyFunctionType : public TypeBase {
     /// Whether the parameter is marked 'inout'
     bool isInOut() const { return Flags.isInOut(); }
   };
+
+  class CanParam : public Param {
+    explicit CanParam(const Param &param) : Param(param) {}
+  public:
+    static CanParam getFromParam(const Param &param) { return CanParam(param); }
+
+    CanType getType() const { return CanType(Param::getType()); }
+  };
+
+  using CanParamArrayRef =
+    ArrayRefView<Param,CanParam,CanParam::getFromParam,/*AccessOriginal*/true>;
 
   /// \brief A class which abstracts out some details necessary for
   /// making a call.
@@ -2515,11 +2526,17 @@ class AnyFunctionType : public TypeBase {
   /// needed.
   static Type composeInput(ASTContext &ctx, ArrayRef<Param> params,
                            bool canonicalVararg);
+  static Type composeInput(ASTContext &ctx, CanParamArrayRef params,
+                           bool canonicalVararg) {
+    return composeInput(ctx, params.getOriginalArray(), canonicalVararg);
+  }
 
   Type getInput() const { return Input; }
   Type getResult() const { return Output; }
   ArrayRef<AnyFunctionType::Param> getParams() const;
   unsigned getNumParams() const { return NumParams; }
+
+  GenericSignature *getOptGenericSignature() const;
 
   ExtInfo getExtInfo() const {
     return ExtInfo(AnyFunctionTypeBits.ExtInfo);
@@ -2561,14 +2578,26 @@ class AnyFunctionType : public TypeBase {
   }
 };
 BEGIN_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
-  typedef AnyFunctionType::ExtInfo ExtInfo;
+  using ExtInfo = AnyFunctionType::ExtInfo;
+  using CanParamArrayRef = AnyFunctionType::CanParamArrayRef;
+
+  static CanAnyFunctionType get(CanGenericSignature signature,
+                                CanType input, CanType result);
+  static CanAnyFunctionType get(CanGenericSignature signature,
+                                CanType input, CanType result,
+                                const ExtInfo &extInfo);
+  static CanAnyFunctionType get(CanGenericSignature signature,
+                                CanParamArrayRef params,
+                                CanType result, const ExtInfo &info);
+
+  CanGenericSignature getOptGenericSignature() const;
 
   CanType getInput() const {
     return getPointer()->getInput()->getCanonicalType();
   }
-  
-  ArrayRef<AnyFunctionType::Param> getParams() const {
-    return getPointer()->getParams();
+
+  CanParamArrayRef getParams() const {
+    return CanParamArrayRef(getPointer()->getParams());
   }
 
   PROXY_CAN_TYPE_SIMPLE_GETTER(getResult)
@@ -2616,20 +2645,19 @@ class FunctionType final : public AnyFunctionType,
 };
 BEGIN_CAN_TYPE_WRAPPER(FunctionType, AnyFunctionType)
   static CanFunctionType get(CanType input, CanType result) {
-    return CanFunctionType(
-             FunctionType::get(input, result)
-               ->getCanonicalType()->castTo<FunctionType>());
+    auto fnType = FunctionType::get(input, result);
+    return cast<FunctionType>(fnType->getCanonicalType());
   }
   static CanFunctionType get(CanType input, CanType result,
                              const ExtInfo &info) {
-    return CanFunctionType(
-             FunctionType::get(input, result, info)
-               ->getCanonicalType()->castTo<FunctionType>());
+    auto fnType = FunctionType::get(input, result, info);
+    return cast<FunctionType>(fnType->getCanonicalType());
   }
-  static CanFunctionType get(ArrayRef<AnyFunctionType::Param> params,
-                             Type result, const ExtInfo &info) {
-    return CanFunctionType(FunctionType::get(params, result, info,
-                                             /*canonicalVararg=*/true));
+  static CanFunctionType get(CanParamArrayRef params, CanType result,
+                             const ExtInfo &info) {
+    auto fnType = FunctionType::get(params.getOriginalArray(),
+                                    result, info, /*canonicalVararg=*/true);
+    return cast<FunctionType>(fnType->getCanonicalType());
   }
 
   CanFunctionType withExtInfo(ExtInfo info) const {
@@ -2749,13 +2777,13 @@ BEGIN_CAN_TYPE_WRAPPER(GenericFunctionType, AnyFunctionType)
 
   /// Create a new generic function type.
   static CanGenericFunctionType get(CanGenericSignature sig,
-                                    ArrayRef<AnyFunctionType::Param> params,
-                                    CanType result,
+                                    CanParamArrayRef params, CanType result,
                                     const ExtInfo &info) {
     // Knowing that the argument types are independently canonical is
     // not sufficient to guarantee that the function type will be canonical.
-    auto fnType = GenericFunctionType::get(sig, params, result, info,
-                                             /*canonicalVararg=*/true);
+    auto fnType = GenericFunctionType::get(sig, params.getOriginalArray(),
+                                           result, info,
+                                           /*canonicalVararg=*/true);
     return cast<GenericFunctionType>(fnType->getCanonicalType());
   }
 
@@ -2773,6 +2801,48 @@ BEGIN_CAN_TYPE_WRAPPER(GenericFunctionType, AnyFunctionType)
   }
 END_CAN_TYPE_WRAPPER(GenericFunctionType, AnyFunctionType)
 
+inline CanAnyFunctionType
+CanAnyFunctionType::get(CanGenericSignature signature,
+                        CanType input, CanType result) {
+  return get(signature, input, result, ExtInfo());
+}
+
+inline CanAnyFunctionType
+CanAnyFunctionType::get(CanGenericSignature signature,
+                        CanType input, CanType result, const ExtInfo &extInfo) {
+  if (signature) {
+    return CanGenericFunctionType::get(signature, input, result, extInfo);
+  } else {
+    return CanFunctionType::get(input, result, extInfo);
+  }
+}
+
+inline CanAnyFunctionType
+CanAnyFunctionType::get(CanGenericSignature signature, CanParamArrayRef params,
+                        CanType result, const ExtInfo &extInfo) {
+  if (signature) {
+    return CanGenericFunctionType::get(signature, params, result, extInfo);
+  } else {
+    return CanFunctionType::get(params, result, extInfo);
+  }
+}
+
+inline GenericSignature *AnyFunctionType::getOptGenericSignature() const {
+  if (auto genericFn = dyn_cast<GenericFunctionType>(this)) {
+    return genericFn->getGenericSignature();
+  } else {
+    return nullptr;
+  }
+}
+
+inline CanGenericSignature CanAnyFunctionType::getOptGenericSignature() const {
+  if (auto genericFn = dyn_cast<GenericFunctionType>(*this)) {
+    return genericFn.getGenericSignature();
+  } else {
+    return CanGenericSignature();
+  }
+}
+
 /// Conventions for passing arguments as parameters.
 enum class ParameterConvention {
   /// This argument is passed indirectly, i.e. by directly passing the address

include/swift/Basic/ArrayRefView.h

@@ -93,6 +93,10 @@ class ArrayRefView {
   Projected front() const { return Project(Array.front()); }
   Projected back() const { return Project(Array.back()); }
 
+  ArrayRefView drop_back(unsigned count = 1) const {
+    return ArrayRefView(Array.drop_back(count));
+  }
+
   ArrayRefView slice(unsigned start) const {
     return ArrayRefView(Array.slice(start));
   }