IDE: Use GenericSignatures and interface types (mostly)

There was a ton of complicated logic here to work around
two problems:

- Same-type constraints were not represented properly in
  RequirementReprs, requiring us to store them in strong form
  and parse them out when printing type interfaces.

- The TypeBase::getAllGenericArgs() method did not do the
  right thing for members of protocols and protocol extensions,
  and so instead of simple calls to Type::subst(), we had
  an elaborate 'ArchetypeTransformer' abstraction repeated
  in two places.

Rewrite this code to use GenericSignatures and
GenericFunctionType instead of old-school GenericParamLists
and PolymorphicFunctionType.

This changes the code completion and AST printer output
slightly. A few of the changes are actually fixes for cases
where the old code didn't handle substitutions properly.
A few others are subjective, for example a generic parameter
list of the form <T : Proto> now prints as <T where T : Proto>.

We can add heuristics to make the output whatever we want
here; the important thing is that now we're using modern
abstractions.

Author: slavapestov

include/swift/AST/PrintOptions.h

@@ -16,6 +16,7 @@
 #include "swift/Basic/STLExtras.h"
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/Identifier.h"
+#include "llvm/ADT/Optional.h"
 #include <limits.h>
 #include <vector>
 
@@ -31,32 +32,21 @@ class DeclContext;
 class Type;
 class ModuleDecl;
 enum DeclAttrKind : unsigned;
-class PrinterTypeTransformer;
 class SynthesizedExtensionAnalyzer;
 struct PrintOptions;
 
 /// Necessary information for archetype transformation during printing.
 struct TypeTransformContext {
-  Type getTypeBase();
-  NominalTypeDecl *getNominal();
-  PrinterTypeTransformer *getTransformer();
-  bool isPrintingSynthesizedExtension();
-  bool isPrintingTypeInterface();
-  TypeTransformContext(PrinterTypeTransformer *Transformer);
-  TypeTransformContext(PrinterTypeTransformer *Transformer,
-                            Type T);
-  TypeTransformContext(PrinterTypeTransformer *Transformer,
-                            NominalTypeDecl *NTD,
-                            SynthesizedExtensionAnalyzer *Analyzer);
-  Type transform(Type Input);
-  StringRef transform(StringRef Input);
+  TypeBase *BaseType;
+  NominalTypeDecl *Nominal = nullptr;
 
-  bool shouldPrintRequirement(ExtensionDecl *ED, StringRef Req);
+  explicit TypeTransformContext(Type T);
+  explicit TypeTransformContext(NominalTypeDecl* NTD);
 
-  ~TypeTransformContext();
-private:
-  struct Implementation;
-  Implementation &Impl;
+  Type getTypeBase() const;
+  NominalTypeDecl *getNominal() const;
+
+  bool isPrintingSynthesizedExtension() const;
 };
 
 typedef std::pair<ExtensionDecl*, bool> ExtensionAndIsSynthesized;
@@ -196,6 +186,10 @@ struct PrintOptions {
   /// ([] and ?), even if there are no sugar type nodes.
   bool SynthesizeSugarOnTypes = false;
 
+  /// \brief Print a dynamic Self type as its underlying type, rather than
+  /// the keyword `Self`.
+  bool StripDynamicSelf = false;
+
   /// \brief If true, the printer will explode a pattern like this:
   /// \code
   ///   var (a, b) = f()
@@ -350,7 +344,7 @@ struct PrintOptions {
   ModuleDecl *CurrentModule = nullptr;
 
   /// \brief The information for converting archetypes to specialized types.
-  std::shared_ptr<TypeTransformContext> TransformContext;
+  llvm::Optional<TypeTransformContext> TransformContext;
 
   /// \brief If this is not \c nullptr then functions (including accessors and
   /// constructors) will be printed with a body that is determined by this
@@ -413,16 +407,15 @@ struct PrintOptions {
     return result;
   }
 
-  static PrintOptions printTypeInterface(Type T, DeclContext *DC);
+  static PrintOptions printTypeInterface(Type T);
 
-  void setArchetypeSelfTransform(Type T, DeclContext *DC);
+  void setArchetypeSelfTransform(Type T);
 
-  void setArchetypeSelfTransformForQuickHelp(Type T, DeclContext *DC);
+  void setArchetypeSelfTransformForQuickHelp(Type T);
 
-  void setArchetypeAndDynamicSelfTransform(Type T, DeclContext *DC);
+  void setArchetypeAndDynamicSelfTransform(Type T);
 
-  void initArchetypeTransformerForSynthesizedExtensions(NominalTypeDecl *D,
-                                    SynthesizedExtensionAnalyzer *SynAnalyzer);
+  void initArchetypeTransformerForSynthesizedExtensions(NominalTypeDecl *D);
 
   void clearArchetypeTransformerForSynthesizedExtensions();
 

include/swift/AST/Requirement.h

@@ -76,6 +76,7 @@ class Requirement {
   }
 
   void dump() const;
+  void print(raw_ostream &os, const PrintOptions &opts) const;
 };
 
 } // end namespace swift

include/swift/IDE/Utils.h

@@ -197,14 +197,6 @@ class SemaLocResolver : public SourceEntityWalker {
 };
 } // namespace ide
 
-class ArchetypeTransformer {
-  struct Implementation;
-  Implementation &Impl;
-public:
-  ArchetypeTransformer(DeclContext *DC, Type Ty);
-  llvm::function_ref<Type(Type)> getTransformerFunc();
-  ~ArchetypeTransformer();
-};
 } // namespace swift
 
 #endif // SWIFT_IDE_UTILS_H

include/swift/Sema/IDETypeChecking.h

@@ -46,8 +46,6 @@ namespace swift {
 
   bool canPossiblyConvertTo(Type T1, Type T2, DeclContext &DC);
 
-  Type lookUpTypeInContext(DeclContext *DC, StringRef Name);
-
   void collectDefaultImplementationForProtocolMembers(ProtocolDecl *PD,
                         llvm::SmallDenseMap<ValueDecl*, ValueDecl*> &DefaultMap);
 
@@ -57,11 +55,6 @@ namespace swift {
   bool typeCheckUnresolvedExpr(DeclContext &DC, Expr* E,
                                Expr *P, SmallVectorImpl<Type> &PossibleTypes);
 
-  /// \brief Given the base type and the trailing identifiers, this function tries
-  /// to infer the type of BaseType.Name1.Name2.Name3
-  /// \returns Resolved type on success, nullptr on error.
-  Type checkMemberType(DeclContext &DC, Type BaseTy, ArrayRef<Identifier> Names);
-
   struct ResolveMemberResult {
     ValueDecl *Favored = nullptr;
     std::vector<ValueDecl*> OtherViables;