Merge pull request #3801 from DougGregor/string-literal-ast

Simplify AST for string literals to not depend on implicit tuple splat.

Author: DougGregor

include/swift/AST/Expr.h

@@ -883,13 +883,13 @@ class BooleanLiteralExpr : public LiteralExpr {
   }
 };
 
-/// StringLiteralExpr - String literal, like '"foo"'.  After semantic
-/// analysis assigns types, this is guaranteed to only have a
-/// BuiltinRawPointerType.
+/// StringLiteralExpr - String literal, like '"foo"'.
 class StringLiteralExpr : public LiteralExpr {
   StringRef Val;
   SourceRange Range;
-  
+  ConcreteDeclRef BuiltinInitializer;
+  ConcreteDeclRef Initializer;
+
 public:
   /// The encoding that should be used for the string literal.
   enum Encoding : unsigned {
@@ -926,6 +926,32 @@ class StringLiteralExpr : public LiteralExpr {
     return StringLiteralExprBits.IsSingleExtendedGraphemeCluster;
   }
 
+  /// Retrieve the builtin initializer that will be used to construct the string
+  /// literal.
+  ///
+  /// Any type-checked string literal will have a builtin initializer, which is
+  /// called first to form a concrete Swift type.
+  ConcreteDeclRef getBuiltinInitializer() const { return BuiltinInitializer; }
+
+  /// Set the builtin initializer that will be used to construct the string
+  /// literal.
+  void setBuiltinInitializer(ConcreteDeclRef builtinInitializer) {
+    BuiltinInitializer = builtinInitializer;
+  }
+
+  /// Retrieve the initializer that will be used to construct the string
+  /// literal from the result of the initializer.
+  ///
+  /// Only string literals that have no builtin literal conformance will have
+  /// this initializer, which will be called on the result of the builtin
+  /// initializer.
+  ConcreteDeclRef getInitializer() const { return Initializer; }
+
+  /// Set the initializer that will be used to construct the string literal.
+  void setInitializer(ConcreteDeclRef initializer) {
+    Initializer = initializer;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::StringLiteral;
   }
@@ -978,7 +1004,9 @@ class MagicIdentifierLiteralExpr : public LiteralExpr {
   };
 private:
   SourceLoc Loc;
-  
+  ConcreteDeclRef BuiltinInitializer;
+  ConcreteDeclRef Initializer;
+
 public:
   MagicIdentifierLiteralExpr(Kind kind, SourceLoc loc, bool implicit = false)
     : LiteralExpr(ExprKind::MagicIdentifierLiteral, implicit), Loc(loc) {
@@ -1031,6 +1059,40 @@ class MagicIdentifierLiteralExpr : public LiteralExpr {
       = static_cast<unsigned>(encoding);
   }
 
+  /// Retrieve the builtin initializer that will be used to construct the string
+  /// literal.
+  ///
+  /// Any type-checked string literal will have a builtin initializer, which is
+  /// called first to form a concrete Swift type.
+  ConcreteDeclRef getBuiltinInitializer() const {
+    assert(isString() && "Magic identifier literal is not a string");
+    return BuiltinInitializer;
+  }
+
+  /// Set the builtin initializer that will be used to construct the string
+  /// literal.
+  void setBuiltinInitializer(ConcreteDeclRef builtinInitializer) {
+    assert(isString() && "Magic identifier literal is not a string");
+    BuiltinInitializer = builtinInitializer;
+  }
+
+  /// Retrieve the initializer that will be used to construct the string
+  /// literal from the result of the initializer.
+  ///
+  /// Only string literals that have no builtin literal conformance will have
+  /// this initializer, which will be called on the result of the builtin
+  /// initializer.
+  ConcreteDeclRef getInitializer() const {
+    assert(isString() && "Magic identifier literal is not a string");
+    return Initializer;
+  }
+
+  /// Set the initializer that will be used to construct the string literal.
+  void setInitializer(ConcreteDeclRef initializer) {
+    assert(isString() && "Magic identifier literal is not a string");
+    Initializer = initializer;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::MagicIdentifierLiteral;
   }

lib/AST/ASTDumper.cpp

@@ -1630,7 +1630,12 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printCommon(E, "string_literal_expr")
       << " encoding=";
     printStringEncoding(E->getEncoding());
-    OS << " value=" << QuotedString(E->getValue()) << ')';
+    OS << " value=" << QuotedString(E->getValue())
+       << " builtin_initializer=";
+    E->getBuiltinInitializer().dump(OS);
+    OS << " initializer=";
+    E->getInitializer().dump(OS);
+    OS << ')';
   }
   void visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {
     printCommon(E, "interpolated_string_literal_expr");
@@ -1657,6 +1662,13 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     case MagicIdentifierLiteralExpr::Column:  OS << "#column"; break;
     case MagicIdentifierLiteralExpr::DSOHandle:  OS << "#dsohandle"; break;
     }
+
+    if (E->isString()) {
+      OS << " builtin_initializer=";
+      E->getBuiltinInitializer().dump(OS);
+      OS << " initializer=";
+      E->getInitializer().dump(OS);
+    }
     OS << ')';
   }
 

lib/AST/Expr.cpp

@@ -370,7 +370,7 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   NO_REFERENCE(MagicIdentifierLiteral);
   NO_REFERENCE(DiscardAssignment);
 
-  SIMPLE_REFERENCE(DeclRef, getDecl);
+  SIMPLE_REFERENCE(DeclRef, getDeclRef);
   SIMPLE_REFERENCE(SuperRef, getSelf);
 
   case ExprKind::Type: {
@@ -381,7 +381,7 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
     return ident->getComponentRange().back()->getBoundDecl();
   }
 
-  SIMPLE_REFERENCE(OtherConstructorDeclRef, getDecl);
+  SIMPLE_REFERENCE(OtherConstructorDeclRef, getDeclRef);
 
   PASS_THROUGH_REFERENCE(DotSyntaxBaseIgnored, getRHS);
 
@@ -439,8 +439,8 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
   NO_REFERENCE(PostfixUnary);
   NO_REFERENCE(Binary);
   NO_REFERENCE(DotSyntaxCall);
-  NO_REFERENCE(ConstructorRefCall);
 
+  PASS_THROUGH_REFERENCE(ConstructorRefCall, getFn);
   PASS_THROUGH_REFERENCE(Load, getSubExpr);
   NO_REFERENCE(TupleShuffle);
   NO_REFERENCE(UnresolvedTypeConversion);