remove support for the experiemental "character literals" feature.

Swift SVN r30509

docs/LangRef.html

@@ -1677,7 +1677,6 @@ <h3 id="expr-literal">Literals</h3>
   <pre class="grammar">
     expr-literal ::= <a href="#integer_literal">integer_literal</a>
     expr-literal ::= <a href="#floating_literal">floating_literal</a>
-    expr-literal ::= <a href="#character_literal">character_literal</a>
     expr-literal ::= <a href="#string_literal">string_literal</a>
     expr-literal ::= expr-array
     expr-literal ::= expr-dictionary
@@ -1696,7 +1695,7 @@ <h3 id="expr-literal">Literals</h3>
      depending on its lexical form.  The type of the literal is inferred
      based on its context.  If there is no contextual type information for an
      expression, all unresolved types are inferred to 'IntegerLiteralType'
-     type, to 'FloatLiteralType', to 'CharacterLiteralType', and to
+     type, to 'FloatLiteralType', and to
      'StringLiteralType', respectively.
      If a literal is used and these types are not defined, then the code is
      malformed.</p>

include/swift/AST/DiagnosticsParse.def

@@ -96,12 +96,6 @@ ERROR(lex_unterminated_block_comment,lexing,none,
 NOTE(lex_comment_start,lexing,none,
      "comment started here", ())
 
-ERROR(lex_invalid_multi_code_point_character_literal,lexing,none,
-      "invalid multiple-code-point character literal", ())
-ERROR(lex_unterminated_character_literal,lexing,none,
-      "unterminated character literal", ())
-ERROR(lex_invalid_character_literal,lexing,none,
-      "invalid character literal", ())
 
 ERROR(lex_unterminated_string,lexing,none,
       "unterminated string literal", ())

include/swift/AST/DiagnosticsSema.def

@@ -1402,8 +1402,6 @@ ERROR(no_IntegerLiteralType_found,sema_tce,none,
       "standard library error: IntegerLiteralType not defined", ())
 ERROR(no_FloatLiteralType_found,sema_tce,none,
       "standard library error: FloatLiteralType not defined", ())
-ERROR(no_CharacterLiteralType_found,sema_tce,none,
-      "standard library error: CharacterLiteralType not defined", ())
 ERROR(no_StringLiteralType_found,sema_tce,none,
       "standard library error: StringLiteralType not defined", ())
 ERROR(no_MaxBuiltinIntegerType_found,sema_tce,none,
@@ -1580,11 +1578,6 @@ ERROR(builtin_boolean_literal_broken_proto,sema_tce,none,
 ERROR(boolean_literal_broken_proto,sema_tce,none,
       "protocol 'BooleanLiteralConvertible' is broken", ())
 
-ERROR(builtin_character_literal_broken_proto,sema_tce,none,
-      "protocol '_BuiltinCharacterLiteralConvertible' is broken", ())
-ERROR(character_literal_broken_proto,sema_tce,none,
-      "protocol 'CharacterLiteralConvertible' is broken", ())
-
 ERROR(builtin_unicode_scalar_literal_broken_proto,sema_tce,none,
       "protocol '_BuiltinUnicodeScalarLiteralConvertible' is broken", ())
 ERROR(unicode_scalar_literal_broken_proto,sema_tce,none,

include/swift/AST/Expr.h

@@ -620,24 +620,6 @@ class BooleanLiteralExpr : public LiteralExpr {
   }
 };
 
-/// CharacterLiteral - Character literal, like 'x'.  After semantic analysis
-/// assigns types, this is guaranteed to only have a 32-bit BuiltinIntegerType.
-class CharacterLiteralExpr : public LiteralExpr {
-  uint32_t Val;
-  SourceLoc Loc;
-public:
-  CharacterLiteralExpr(uint32_t Val, SourceLoc Loc)
-    : LiteralExpr(ExprKind::CharacterLiteral, /*Implicit=*/false),
-      Val(Val), Loc(Loc) {}
-
-  uint32_t getValue() const { return Val; }
-  SourceRange getSourceRange() const { return Loc; }
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::CharacterLiteral;
-  }
-};
-
 /// StringLiteralExpr - String literal, like '"foo"'.  After semantic
 /// analysis assigns types, this is guaranteed to only have a
 /// BuiltinRawPointerType.

include/swift/AST/ExprNodes.def

@@ -54,7 +54,6 @@ ABSTRACT_EXPR(Literal, Expr)
     EXPR(FloatLiteral, NumberLiteralExpr)
   EXPR_RANGE(NumberLiteral, IntegerLiteral, FloatLiteral)
   EXPR(BooleanLiteral, LiteralExpr)
-  EXPR(CharacterLiteral, LiteralExpr)
   EXPR(StringLiteral, LiteralExpr)
   EXPR(InterpolatedStringLiteral, LiteralExpr)
   EXPR(MagicIdentifierLiteral, LiteralExpr)

include/swift/AST/KnownIdentifiers.def

@@ -82,10 +82,6 @@ IDENTIFIER(BooleanLiteralType)
 IDENTIFIER_(builtinBooleanLiteral)
 IDENTIFIER(booleanLiteral)
 
-IDENTIFIER(CharacterLiteralType)
-IDENTIFIER(characterLiteral)
-IDENTIFIER_(builtinCharacterLiteral)
-
 IDENTIFIER(ExtendedGraphemeClusterLiteralType)
 IDENTIFIER_(builtinExtendedGraphemeClusterLiteral)
 IDENTIFIER(extendedGraphemeClusterLiteral)

include/swift/AST/KnownProtocols.def

@@ -53,7 +53,6 @@ PROTOCOL(_DestructorSafeContainer)
 
 LITERAL_CONVERTIBLE_PROTOCOL(ArrayLiteralConvertible, array)
 LITERAL_CONVERTIBLE_PROTOCOL(BooleanLiteralConvertible, boolean)
-LITERAL_CONVERTIBLE_PROTOCOL(CharacterLiteralConvertible, character)
 LITERAL_CONVERTIBLE_PROTOCOL(DictionaryLiteralConvertible, dictionary)
 LITERAL_CONVERTIBLE_PROTOCOL(ExtendedGraphemeClusterLiteralConvertible, character)
 LITERAL_CONVERTIBLE_PROTOCOL(FloatLiteralConvertible, floating-point)
@@ -66,7 +65,6 @@ LITERAL_CONVERTIBLE_PROTOCOL(_ColorLiteralConvertible, color)
 LITERAL_CONVERTIBLE_PROTOCOL(_ImageLiteralConvertible, image)
 
 BUILTIN_LITERAL_CONVERTIBLE_PROTOCOL(_BuiltinBooleanLiteralConvertible)
-BUILTIN_LITERAL_CONVERTIBLE_PROTOCOL(_BuiltinCharacterLiteralConvertible)
 BUILTIN_LITERAL_CONVERTIBLE_PROTOCOL(_BuiltinExtendedGraphemeClusterLiteralConvertible)
 BUILTIN_LITERAL_CONVERTIBLE_PROTOCOL(_BuiltinFloatLiteralConvertible)
 BUILTIN_LITERAL_CONVERTIBLE_PROTOCOL(_BuiltinIntegerLiteralConvertible)

include/swift/Basic/LangOptions.h

@@ -31,9 +31,6 @@ namespace swift {
   /// provide compiler debugging facilities.
   class LangOptions {
   public:
-
-    /// \brief Enable legacy character literals.
-    bool EnableCharacterLiterals = false;
 
     /// \brief Whether we are debugging the constraint solver.
     ///

include/swift/IDE/SyntaxModel.h

@@ -34,7 +34,6 @@ enum class SyntaxNodeKind : uint8_t {
   String,
   /// Marks the parens for a string interpolation.
   StringInterpolationAnchor,
-  Character,
   CommentLine,
   CommentBlock,
   DocCommentLine,

include/swift/Option/FrontendOptions.td

@@ -187,9 +187,6 @@ def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;
 
-def enable_character_literals : Flag<["-"], "enable-character-literals">,
-  HelpText<"Enable legacy character literals">;
-
 def enable_objc_implicit_properties :
   Flag<["-"], "enable-objc-implicit-properties">,
   HelpText<"Import Objective-C \"implicit properties\" as properties">;

include/swift/Parse/Lexer.h

@@ -340,9 +340,6 @@ class Lexer {
     return getStringLiteralSegments(Str, Segments, Diags);
   }
 
-  /// \brief Return the UTF32 codepoint for the specified character literal.
-  uint32_t getEncodedCharacterLiteral(const Token &Tok);
-
   static SourceLoc getSourceLoc(const char *Loc) {
     return SourceLoc(llvm::SMLoc::getFromPointer(Loc));
   }
@@ -410,7 +407,6 @@ class Lexer {
 
   unsigned lexCharacter(const char *&CurPtr,
                         bool StopAtDoubleQuote, bool EmitDiagnostics);
-  void lexCharacterLiteral();
   void lexStringLiteral();
   void lexEscapedIdentifier();
 

include/swift/Parse/Token.h

@@ -36,7 +36,6 @@ enum class tok {
   integer_literal,
   floating_literal,
   string_literal,
-  character_literal,
   sil_local_name,      // %42 in SIL mode.
   pound_if,
   pound_else,

include/swift/SIL/SILBuilder.h

@@ -306,9 +306,6 @@ class SILBuilder {
   IntegerLiteralInst *createIntegerLiteral(IntegerLiteralExpr *E) {
     return insert(IntegerLiteralInst::create(E, F));
   }
-  IntegerLiteralInst *createIntegerLiteral(CharacterLiteralExpr *E) {
-    return insert(IntegerLiteralInst::create(E, F));
-  }
   IntegerLiteralInst *createIntegerLiteral(SILLocation Loc, SILType Ty,
                                            intmax_t Value) {
     return insert(IntegerLiteralInst::create(Loc, Ty, Value, F));

include/swift/SIL/SILInstruction.h

@@ -31,7 +31,6 @@
 
 namespace swift {
 
-class CharacterLiteralExpr;
 class DeclRefExpr;
 class FloatLiteralExpr;
 class FuncDecl;
@@ -945,15 +944,14 @@ class GlobalAddrInst : public LiteralInst {
 };
 
 /// IntegerLiteralInst - Encapsulates an integer constant, as defined originally
-/// by an an IntegerLiteralExpr or CharacterLiteralExpr.
+/// by an IntegerLiteralExpr.
 class IntegerLiteralInst : public LiteralInst {
   unsigned numBits;
 
   IntegerLiteralInst(SILLocation Loc, SILType Ty, const APInt &Value);
 
 public:
   static IntegerLiteralInst *create(IntegerLiteralExpr *E, SILFunction &B);
-  static IntegerLiteralInst *create(CharacterLiteralExpr *E, SILFunction &B);
   static IntegerLiteralInst *create(SILLocation Loc, SILType Ty,
                                     intmax_t Value, SILFunction &B);
   static IntegerLiteralInst *create(SILLocation Loc, SILType Ty,

lib/AST/ASTDumper.cpp

@@ -1411,10 +1411,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
       << ')';
   }
 
-  void visitCharacterLiteralExpr(CharacterLiteralExpr *E) {
-    printCommon(E, "character_literal_expr") << " value=" << E->getValue()<<')';
-  }
-
   void printStringEncoding(StringLiteralExpr::Encoding encoding) {
     switch (encoding) {
     case StringLiteralExpr::UTF8: OS << "utf8"; break;

lib/AST/Expr.cpp

@@ -310,7 +310,6 @@ bool Expr::canAppendCallParentheses() const {
   case ExprKind::IntegerLiteral:
   case ExprKind::FloatLiteral:
   case ExprKind::BooleanLiteral:
-  case ExprKind::CharacterLiteral:
   case ExprKind::StringLiteral:
   case ExprKind::InterpolatedStringLiteral:
   case ExprKind::MagicIdentifierLiteral:

lib/Frontend/CompilerInvocation.cpp

@@ -647,8 +647,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.DisableAvailabilityChecking |=
       Args.hasArg(OPT_disable_availability_checking);
 
-  Opts.EnableCharacterLiterals |= Args.hasArg(OPT_enable_character_literals);
-
   if (auto A = Args.getLastArg(OPT_enable_access_control,
                                OPT_disable_access_control)) {
     Opts.EnableAccessControl

lib/IDE/SyntaxModel.cpp

@@ -108,7 +108,6 @@ SyntaxModelContext::SyntaxModelContext(SourceFile &SrcFile)
       case tok::integer_literal: Kind = SyntaxNodeKind::Integer; break;
       case tok::floating_literal: Kind = SyntaxNodeKind::Floating; break;
       case tok::string_literal: Kind = SyntaxNodeKind::String; break;
-      case tok::character_literal: Kind = SyntaxNodeKind::Character; break;
       case tok::comment:
         if (Tok.getText().startswith("///"))
           Kind = SyntaxNodeKind::DocCommentLine;

lib/IRGen/GenMeta.cpp

@@ -4823,7 +4823,6 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::_DestructorSafeContainer:
   case KnownProtocolKind::ArrayLiteralConvertible:
   case KnownProtocolKind::BooleanLiteralConvertible:
-  case KnownProtocolKind::CharacterLiteralConvertible:
   case KnownProtocolKind::DictionaryLiteralConvertible:
   case KnownProtocolKind::ExtendedGraphemeClusterLiteralConvertible:
   case KnownProtocolKind::FloatLiteralConvertible:
@@ -4835,7 +4834,6 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::_ColorLiteralConvertible:
   case KnownProtocolKind::_ImageLiteralConvertible:
   case KnownProtocolKind::_BuiltinBooleanLiteralConvertible:
-  case KnownProtocolKind::_BuiltinCharacterLiteralConvertible:
   case KnownProtocolKind::_BuiltinExtendedGraphemeClusterLiteralConvertible:
   case KnownProtocolKind::_BuiltinFloatLiteralConvertible:
   case KnownProtocolKind::_BuiltinIntegerLiteralConvertible:

lib/Parse/Lexer.cpp

@@ -1008,75 +1008,6 @@ unsigned Lexer::lexCharacter(const char *&CurPtr, bool StopAtDoubleQuote,
   return CharValue;
 }
 
-
-/// lexCharacterLiteral:
-///   character_literal ::= '([^'\\\n\r]|character_escape)'
-void Lexer::lexCharacterLiteral() {
-  const char *TokStart = CurPtr-1;
-  assert(*TokStart == '\'' && "Unexpected start");
-
-  unsigned CharValue = lexCharacter(CurPtr, false, true);
-
-  // If we have '', we have an invalid character literal.
-  if (CharValue == ~0U) {
-    diagnose(TokStart, diag::lex_invalid_character_literal);
-    if (*CurPtr == '\'')
-      ++CurPtr;
-    return formToken(tok::character_literal, TokStart);
-  }
-
-  // If this wasn't a normal character, then this is a malformed character.
-  if (CharValue == ~1U) {
-    // Skip until we see a single quote, newline, or EOF, whatever comes first.
-    while (true) {
-      const char C = *CurPtr;
-      if (C == '\n' || C == '\r' || C == '\'' || C == 0)
-        break;
-      CurPtr++;
-    }
-
-    // If we successfully skipped to the single quote, assume that it
-    // terminates the character literal and eat it now.
-    if (*CurPtr == '\'')
-      ++CurPtr;
-    return formToken(tok::character_literal, TokStart);
-  }
-
-  if (*CurPtr != '\'') {
-    // Skip until we see a single quote, newline, or EOF, whatever comes first.
-    while (true) {
-      const char C = *CurPtr;
-      if (C == '\n' || C == '\r' || C == '\'' || C == 0)
-        break;
-      CurPtr++;
-    }
-
-    // If we successfully skipped to the single quote, assume that it
-    // terminates the character literal and eat it now.
-    if (*CurPtr == '\'') {
-      diagnose(TokStart, diag::lex_invalid_multi_code_point_character_literal);
-      ++CurPtr;
-    } else {
-      diagnose(TokStart, diag::lex_unterminated_character_literal);
-    }
-    return formToken(tok::unknown, TokStart);
-  }
-  ++CurPtr;
-  return formToken(tok::character_literal, TokStart);
-}
-
-uint32_t Lexer::getEncodedCharacterLiteral(const Token &Tok) {
-  assert(Tok.is(tok::character_literal));
-  const char *CharStart = Tok.getText().data() + 1;
-  uint32_t CodePoint = lexCharacter(CharStart, false, false);
-  if (CodePoint == ~0U || CodePoint == ~1U) {
-    // We have already diagnosed an error.  Return REPLACEMENT CHARACTER as the
-    // value.
-    return 0xFFFD;
-  }
-  return CodePoint;
-}
-
 /// skipToEndOfInterpolatedExpression - Given the first character after a \(
 /// sequence in a string literal (the start of an interpolated expression), 
 /// scan forward to the end of the interpolated expression and return the end.
@@ -1409,11 +1340,6 @@ void Lexer::lexImpl() {
   const char *TokStart = CurPtr;
 
   switch (*CurPtr++) {
-  case '\'':
-    if (LangOpts.EnableCharacterLiterals)
-      return lexCharacterLiteral();
-  SWIFT_FALLTHROUGH;
-
   default: {
     char const *tmp = CurPtr-1;
     if (advanceIfValidStartOfIdentifier(tmp, BufferEnd))

lib/Parse/ParseExpr.cpp

@@ -643,7 +643,6 @@ MagicIdentifierLiteralExpr::Kind getMagicIdentifierLiteralKind(tok Kind) {
 ///     integer_literal
 ///     floating_literal
 ///     string_literal
-///     character_literal
 ///     nil
 ///     true
 ///     false
@@ -719,14 +718,6 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
                                                            /*Implicit=*/false));
     break;
   }
-  case tok::character_literal: {
-    uint32_t Codepoint = L->getEncodedCharacterLiteral(Tok);
-    SourceLoc Loc = consumeToken(tok::character_literal);
-    Result = makeParserResult(
-        new (Context) CharacterLiteralExpr(Codepoint, Loc));
-    break;
-  }
-
   case tok::at_sign:
     // Objective-C programmers habitually type @"foo", so recover gracefully
     // with a fixit.  If this isn't @"foo", just handle it like an unknown

lib/SIL/SILInstructions.cpp

@@ -349,13 +349,6 @@ IntegerLiteralInst::create(IntegerLiteralExpr *E, SILFunction &F) {
                 E->getValue(), F);
 }
 
-IntegerLiteralInst *
-IntegerLiteralInst::create(CharacterLiteralExpr *E, SILFunction &F) {
-  return create(E,
-              SILType::getPrimitiveObjectType(E->getType()->getCanonicalType()),
-              E->getValue(), F);
-}
-
 /// getValue - Return the APInt for the underlying integer literal.
 APInt IntegerLiteralInst::getValue() const {
   return APInt(numBits,

lib/SILGen/SILGenExpr.cpp

@@ -162,8 +162,7 @@ namespace {
     RValue visitIntegerLiteralExpr(IntegerLiteralExpr *E, SGFContext C);
     RValue visitFloatLiteralExpr(FloatLiteralExpr *E, SGFContext C);
     RValue visitBooleanLiteralExpr(BooleanLiteralExpr *E, SGFContext C);
-    RValue visitCharacterLiteralExpr(CharacterLiteralExpr *E, SGFContext C);
-
+
     RValue emitStringLiteral(Expr *E, StringRef Str, SGFContext C,
                              StringLiteralExpr::Encoding encoding);
 
@@ -756,12 +755,6 @@ RValue RValueEmitter::visitBooleanLiteralExpr(BooleanLiteralExpr *E,
   return RValue(SGF, E, ManagedValue::forUnmanaged(boolValue));
 }
 
-RValue RValueEmitter::visitCharacterLiteralExpr(CharacterLiteralExpr *E,
-                                                SGFContext C) {
-  return RValue(SGF, E,
-                ManagedValue::forUnmanaged(SGF.B.createIntegerLiteral(E)));
-}
-
 RValue RValueEmitter::emitStringLiteral(Expr *E, StringRef Str,
                                         SGFContext C,
                                         StringLiteralExpr::Encoding encoding) {