[clang][Interp] Implement String-and CharacterLiterals

[tbaeder]

Summary

Including a fix for the ambiguous APInt constructor.

Precommit CI should work on this now.

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
   bool VisitInitListExpr(const InitListExpr *E);
   bool VisitConstantExpr(const ConstantExpr *E);
   bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
   bool VisitMemberExpr(const MemberExpr *E);
   bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E);
   bool VisitOpaqueValueExpr(const OpaqueValueExpr *E);
   bool VisitAbstractConditionalOperator(const AbstractConditionalOperator *E);
+  bool VisitStringLiteral(const StringLiteral *E);
+  bool VisitCharacterLiteral(const CharacterLiteral *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
                       llvm::function_ref<bool(PrimType)> Indirect);
 
   /// Emits an APInt constant.
   bool emitConst(PrimType T, const llvm::APInt &Value, const Expr *E);
 
   /// Emits an integer constant.
   template <typename T> bool emitConst(const Expr *E, T Value) {
     QualType Ty = E->getType();
-    APInt WrappedValue(getIntWidth(Ty), Value, std::is_signed<T>::value);
+    APInt WrappedValue(getIntWidth(Ty), static_cast<uint64_t>(Value),
+                       std::is_signed<T>::value);
     return emitConst(*Ctx.classify(Ty), WrappedValue, E);
   }
 
   /// Returns the index of a global.
   llvm::Optional<unsigned> getGlobalIdx(const VarDecl *VD);
 
   /// Emits the initialized pointer.
   bool emitInitFn() {

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!this->visit(FalseExpr))
     return false;
 
   this->fallthrough(LabelEnd);
   this->emitLabel(LabelEnd);
 
   return true;
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitStringLiteral(const StringLiteral *E) {
+  unsigned StringIndex = P.createGlobalString(E);
+  return this->emitGetPtrGlobal(StringIndex, E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCharacterLiteral(
+    const CharacterLiteral *E) {
+  return this->emitConst(E, E->getValue());
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visit(const Expr *E) {
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/false);

clang/test/AST/Interp/literals.cpp

 namespace bitOr {
   static_assert((10 | 1) == 11, "");
   static_assert((10 | 10) == 10, "");
 
   static_assert((1337 | -1) == -1, "");
   static_assert((0 | gimme(12)) == 12, "");
   static_assert((12 | true) == 13, "");
 };
+
+namespace strings {
+  constexpr const char *S = "abc";
+  static_assert(S[0] == 97, "");
+  static_assert(S[1] == 98, "");
+  static_assert(S[2] == 99, "");
+  static_assert(S[3] == 0, "");
+
+  static_assert("foobar"[2] == 'o', "");
+  static_assert(2["foobar"] == 'o', "");
+
+  constexpr const wchar_t *wide = L"bar";
+  static_assert(wide[0] == L'b', "");
+
+  constexpr const char32_t *u32 = U"abc";
+  static_assert(u32[1] == U'b', "");
+
+  constexpr char32_t c = U'\U0001F60E';
+  static_assert(c == 0x0001F60EL, "");
+
+  constexpr char k = -1;
+  static_assert(k == -1, "");
+
+  static_assert('\N{LATIN CAPITAL LETTER E}' == 'E', "");
+  static_assert('\t' == 9, "");
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmultichar"
+  constexpr int mc = 'abc';
+  static_assert(mc == 'abc', "");
+  __WCHAR_TYPE__ wm = L'abc'; // ref-error{{wide character literals may not contain multiple characters}} \
+                              // expected-error{{wide character literals may not contain multiple characters}}
+  __WCHAR_TYPE__ wu = u'abc'; // ref-error{{Unicode character literals may not contain multiple characters}} \
+                              // expected-error{{Unicode character literals may not contain multiple characters}}
+  __WCHAR_TYPE__ wU = U'abc'; // ref-error{{Unicode character literals may not contain multiple characters}} \
+                              // expected-error{{Unicode character literals may not contain multiple characters}}
+#if __cplusplus > 201103L
+  __WCHAR_TYPE__ wu8 = u8'abc'; // ref-error{{Unicode character literals may not contain multiple characters}} \
+                                // expected-error{{Unicode character literals may not contain multiple characters}}
+#endif
+
+#pragma clang diagnostic pop
+};

clang/test/Lexer/char-escapes.c

 // RUN: %clang_cc1 -fsyntax-only -pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -pedantic -fexperimental-new-constant-interpreter -verify %s
 
 int test['\\' == 92 ? 1 : -1];
 int test['\"' == 34 ? 1 : -1];
 int test['\'' == 39 ? 1 : -1];
 int test['\?' == 63 ? 1 : -1];
 int test['\a' == 7 ? 1 : -1];
 int test['\b' == 8 ? 1 : -1];
 int test['\e' == 27 ? 1 : -1]; // expected-warning {{non-standard escape}}