Merge pull request #2538 from IngmarStein/master

swift-ci · web-flow · commit 7e7d1dbf21ed · 2016-06-29T16:57:16.000-07:00
diff --git a/lib/ClangImporter/ImportMacro.cpp b/lib/ClangImporter/ImportMacro.cpp
@@ -70,13 +70,29 @@ static bool isInSystemModule(DeclContext *D) {
   return false;
 }
 
+static ValueDecl *
+createMacroConstant(ClangImporter::Implementation &Impl,
+                    const clang::MacroInfo *macro,
+                    Identifier name,
+                    DeclContext *dc,
+                    Type type,
+                    const clang::APValue &value,
+                    ConstantConvertKind convertKind,
+                    bool isStatic,
+                    ClangNode ClangN) {
+  Impl.ImportedMacroConstants[macro] = {value, type};
+  return Impl.createConstant(name, dc, type, value, convertKind, isStatic,
+                             ClangN);
+}
+
 static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
                                        DeclContext *DC,
                                        const clang::MacroInfo *MI,
                                        Identifier name,
                                        const clang::Token *signTok,
                                        const clang::Token &tok,
-                                       const clang::MacroInfo *ClangN) {
+                                       const clang::MacroInfo *ClangN,
+                                       const clang::QualType *castType) {
   assert(tok.getKind() == clang::tok::numeric_constant &&
          "not a numeric token");
   {
@@ -96,12 +112,21 @@ static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
 
   if (const clang::Expr *parsed = parseNumericLiteral<>(Impl, tok)) {
     auto clangTy = parsed->getType();
-    auto type = Impl.importType(clangTy, ImportTypeKind::Value,
-                                isInSystemModule(DC),
-                                /*isFullyBridgeable*/false);
-    if (!type)
+    auto literalType = Impl.importType(clangTy, ImportTypeKind::Value,
+                                       isInSystemModule(DC),
+                                       /*isFullyBridgeable*/false);
+    if (!literalType)
       return nullptr;
 
+    Type constantType;
+    if (castType) {
+      constantType = Impl.importType(*castType, ImportTypeKind::Value,
+                                     isInSystemModule(DC),
+                                     /*isFullyBridgeable*/false);
+    } else {
+      constantType = literalType;
+    }
+
     if (auto *integer = dyn_cast<clang::IntegerLiteral>(parsed)) {
       // Determine the value.
       llvm::APSInt value{integer->getValue(), clangTy->isUnsignedIntegerType()};
@@ -117,7 +142,8 @@ static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
         }
       }
 
-      return Impl.createConstant(name, DC, type, clang::APValue(value),
+      return createMacroConstant(Impl, MI, name, DC, constantType,
+                                 clang::APValue(value),
                                  ConstantConvertKind::Coerce,
                                  /*static*/ false, ClangN);
     }
@@ -134,7 +160,8 @@ static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
         value.changeSign();
       }
 
-      return Impl.createConstant(name, DC, type, clang::APValue(value),
+      return createMacroConstant(Impl, MI, name, DC, constantType,
+                                 clang::APValue(value),
                                  ConstantConvertKind::Coerce,
                                  /*static*/ false, ClangN);
     }
@@ -148,6 +175,13 @@ static bool isStringToken(const clang::Token &tok) {
          tok.is(clang::tok::utf8_string_literal);
 }
 
+static bool isBinaryOperator(const clang::Token &tok) {
+  return tok.is(clang::tok::amp) ||
+         tok.is(clang::tok::pipe) ||
+         tok.is(clang::tok::ampamp) ||
+         tok.is(clang::tok::pipepipe);
+}
+
 // Describes the kind of string literal we're importing.
 enum class MappedStringLiteralKind {
   CString,  // "string"
@@ -191,11 +225,12 @@ static ValueDecl *importLiteral(ClangImporter::Implementation &Impl,
                                 const clang::MacroInfo *MI,
                                 Identifier name,
                                 const clang::Token &tok,
-                                const clang::MacroInfo *ClangN) {
+                                const clang::MacroInfo *ClangN,
+                                const clang::QualType *castType = nullptr) {
   switch (tok.getKind()) {
   case clang::tok::numeric_constant:
     return importNumericLiteral(Impl, DC, MI, name, /*signTok*/nullptr, tok,
-                                ClangN);
+                                ClangN, castType);
 
   case clang::tok::string_literal:
   case clang::tok::utf8_string_literal:
@@ -228,7 +263,8 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
                               DeclContext *DC,
                               Identifier name,
                               const clang::MacroInfo *macro,
-                              const clang::MacroInfo *ClangN) {
+                              const clang::MacroInfo *ClangN,
+                              clang::QualType *castType = nullptr) {
   if (name.empty()) return nullptr;
 
   auto numTokens = macro->getNumTokens();
@@ -243,17 +279,55 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
     numTokens -= 2;
   }
 
+  // Handle tokens starting with a type cast
+  bool castTypeIsId = false;
+  clang::QualType castClangType;
+  if (numTokens > 3 &&
+      tokenI[0].is(clang::tok::l_paren) &&
+      tokenI[1].is(clang::tok::identifier) &&
+      tokenI[2].is(clang::tok::r_paren)) {
+    if (castType) {
+      // this is a nested cast
+      return nullptr;
+    }
+
+    auto identifierInfo = tokenI[1].getIdentifierInfo();
+    if (identifierInfo->isStr("id")) {
+      castTypeIsId = true;
+    }
+    auto identifierName = identifierInfo->getName();
+    auto &identifier = impl.getClangASTContext().Idents.get(identifierName);
+    auto parsedType = impl.getClangSema().getTypeName(identifier,
+                                                    clang::SourceLocation(),
+                                                    /*scope*/nullptr);
+    if (parsedType) {
+      castClangType = parsedType.get();
+      castType = &castClangType;
+    } else {
+      return nullptr;
+    }
+    tokenI += 3;
+    numTokens -= 3;
+  }
+
   // FIXME: Ask Clang to try to parse and evaluate the expansion as a constant
   // expression instead of doing these special-case pattern matches.
   switch (numTokens) {
   case 1: {
     // Check for a single-token expansion of the form <literal>.
     // TODO: or <identifier>.
     const clang::Token &tok = *tokenI;
-    
+
+    if (castTypeIsId && tok.is(clang::tok::numeric_constant)) {
+      auto *integerLiteral =
+        parseNumericLiteral<clang::IntegerLiteral>(impl, tok);
+      if (integerLiteral && integerLiteral->getValue() == 0)
+        return importNil(impl, DC, name, ClangN);
+    }
+
     // If it's a literal token, we might be able to translate the literal.
     if (tok.isLiteral()) {
-      return importLiteral(impl, DC, macro, name, tok, ClangN);
+      return importLiteral(impl, DC, macro, name, tok, ClangN, castType);
     }
 
     if (tok.is(clang::tok::identifier)) {
@@ -287,9 +361,10 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
     // but are pervasive in C headers anyway.
     clang::Token const &first = tokenI[0];
     clang::Token const &second = tokenI[1];
-    
+
     if (isSignToken(first) && second.is(clang::tok::numeric_constant))
-      return importNumericLiteral(impl, DC, macro, name, &first, second, ClangN);
+      return importNumericLiteral(impl, DC, macro, name, &first, second, ClangN,
+                                  castType);
 
     // We also allow @"string".
     if (first.is(clang::tok::at) && isStringToken(second))
@@ -319,9 +394,76 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
 
       llvm::APSInt value{ base->getValue() << shift->getValue(),
                           clangTy->isUnsignedIntegerType() };
-      return impl.createConstant(name, DC, type, clang::APValue(value),
+      return createMacroConstant(impl, macro, name, DC, type,
+                                 clang::APValue(value),
                                  ConstantConvertKind::Coerce, /*static=*/false,
                                  ClangN);
+    // Check for a expression of the form (FLAG1 | FLAG2), (FLAG1 & FLAG2),
+    // (FLAG1 || FLAG2), or (FLAG1 || FLAG2)
+    } else if (tokenI[0].is(clang::tok::identifier) &&
+               isBinaryOperator(tokenI[1]) &&
+               tokenI[2].is(clang::tok::identifier)) {
+      auto firstID = tokenI[0].getIdentifierInfo();
+      auto secondID = tokenI[2].getIdentifierInfo();
+
+      if (firstID->hasMacroDefinition() && secondID->hasMacroDefinition()) {
+        auto firstMacroInfo = impl.getClangPreprocessor().getMacroInfo(firstID);
+        auto secondMacroInfo = impl.getClangPreprocessor().getMacroInfo(
+                                                                      secondID);
+        auto firstIterator = impl.ImportedMacroConstants.find(firstMacroInfo);
+        if (firstIterator == impl.ImportedMacroConstants.end()) {
+          return nullptr;
+        }
+        auto secondIterator = impl.ImportedMacroConstants.find(secondMacroInfo);
+        if (secondIterator == impl.ImportedMacroConstants.end()) {
+          return nullptr;
+        }
+
+        auto firstConstant = firstIterator->second;
+        auto secondConstant = secondIterator->second;
+        auto firstValue = firstConstant.first;
+        auto secondValue = secondConstant.first;
+        if (!firstValue.isInt() || !secondValue.isInt()) {
+          return nullptr;
+        }
+
+        auto firstInteger = firstValue.getInt();
+        auto secondInteger = secondValue.getInt();
+        auto type = firstConstant.second;
+
+        clang::APValue value;
+        if (tokenI[1].is(clang::tok::pipe)) {
+          if (firstInteger.getBitWidth() == secondInteger.getBitWidth()) {
+            value = clang::APValue(firstInteger | secondInteger);
+          } else {
+            return nullptr;
+          }
+        } else if (tokenI[1].is(clang::tok::amp)) {
+          if (firstInteger.getBitWidth() == secondInteger.getBitWidth()) {
+            value = clang::APValue(firstInteger & secondInteger);
+          } else {
+            return nullptr;
+          }
+        } else if (tokenI[1].is(clang::tok::pipepipe)) {
+          auto firstBool = firstInteger.getBoolValue();
+          auto secondBool = firstInteger.getBoolValue();
+          auto result = firstBool || secondBool;
+          value = clang::APValue(result ?
+                                 llvm::APSInt::get(1) : llvm::APSInt::get(0));
+        } else if (tokenI[1].is(clang::tok::ampamp)) {
+          auto firstBool = firstInteger.getBoolValue();
+          auto secondBool = firstInteger.getBoolValue();
+          auto result = firstBool && secondBool;
+          value = clang::APValue(result ?
+                                 llvm::APSInt::get(1) : llvm::APSInt::get(0));
+        } else {
+          return nullptr;
+        }
+        return createMacroConstant(impl, macro, name, DC, type,
+                                   value,
+                                   ConstantConvertKind::Coerce,
+                                   /*static=*/false, ClangN);
+      }
     }
     break;
   }
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
@@ -386,6 +386,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                  SmallVector<std::pair<clang::MacroInfo *, ValueDecl *>, 2>>
     ImportedMacros;
 
+  // Mapping from macro to value for macros that expand to constant values.
+  llvm::DenseMap<const clang::MacroInfo *, std::pair<clang::APValue, Type>>
+    ImportedMacroConstants;
+
   /// Keeps track of active selector-based lookups, so that we don't infinitely
   /// recurse when checking whether a method with a given selector has already
   /// been imported.
diff --git a/test/IDE/Inputs/mock-sdk/Foo.annotated.txt b/test/IDE/Inputs/mock-sdk/Foo.annotated.txt
@@ -181,11 +181,16 @@ class <loc>FooClassDerived</loc> : <ref:Class>FooClassBase</ref>, <ref:Protocol>
   func <loc>fooProtoFuncWithExtraIndentation2()</loc></decl>
   <decl:Func>class func <loc>fooProtoClassFunc()</loc></decl>
 }</decl>
+<decl:TypeAlias>typealias <loc>typedef_int_t</loc> = <ref:Struct>Int32</ref></decl>
 <decl:Var>var <loc>FOO_MACRO_1</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_2</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_3</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_4</loc>: <ref:Struct>UInt32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_5</loc>: <ref:Struct>UInt64</ref> { get }</decl>
+<decl:Var>var <loc>FOO_MACRO_6</loc>: <ref:TypeAlias>typedef_int_t</ref> { get }</decl>
+<decl:Var>var <loc>FOO_MACRO_7</loc>: <ref:TypeAlias>typedef_int_t</ref> { get }</decl>
+<decl:Var>var <loc>FOO_MACRO_OR</loc>: <ref:Struct>Int32</ref> { get }</decl>
+<decl:Var>var <loc>FOO_MACRO_AND</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_REDEF_1</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Var>var <loc>FOO_MACRO_REDEF_2</loc>: <ref:Struct>Int32</ref> { get }</decl>
 <decl:Func>func <loc>theLastDeclInFoo()</loc></decl>
@@ -235,6 +240,8 @@ class <loc>FooClassDerived</loc> : <ref:Class>FooClassBase</ref>, <ref:Protocol>
   <decl:Constructor><loc>init!()</loc></decl>
   <decl:Constructor>convenience <loc>init!(<decl:Param>float f: <ref:Struct>Float</ref></decl>)</loc></decl>
 }</decl>
+<decl:Var>@available(*, unavailable, message: "use 'nil' instead of this imported macro")
+var <loc>FOO_NIL</loc>: ()</decl>
 <decl:Class>class <loc>FooUnavailableMembers</loc> : <ref:Class>FooClassBase</ref> {
   <decl:Constructor>convenience <loc>init!(<decl:Param>int i: <ref:Struct>Int32</ref></decl>)</loc></decl>
   <decl:Func>@available(*, unavailable, message: "use object construction 'FooUnavailableMembers(int:)'")
diff --git a/test/IDE/Inputs/mock-sdk/Foo.framework/Headers/Foo.h b/test/IDE/Inputs/mock-sdk/Foo.framework/Headers/Foo.h
@@ -180,13 +180,19 @@ int fooFuncUsingVararg(int a, ...);// This comment should not show without decl.
 
 @class BarForwardDeclaredClass;
 enum BarforwardDeclaredEnum;
+typedef int typedef_int_t;
 
 /* FOO_MACRO_1 is the answer */
 #define FOO_MACRO_1 0
 #define FOO_MACRO_2 1
 #define FOO_MACRO_3 (-1) // Don't use FOO_MACRO_3 on Saturdays.
 #define FOO_MACRO_4 0xffffffffu
 #define FOO_MACRO_5 0xffffffffffffffffull
+#define FOO_MACRO_6 ((typedef_int_t) 42)
+#define FOO_MACRO_7 ((typedef_int_t) -1)
+#define FOO_MACRO_OR (FOO_MACRO_2 | FOO_MACRO_6)
+#define FOO_MACRO_AND (FOO_MACRO_2 & FOO_MACRO_6)
+#define FOO_MACRO_BITWIDTH (FOO_MACRO_4 & FOO_MACRO_5)
 
 #define FOO_MACRO_UNDEF_1 0
 #undef FOO_MACRO_UNDEF_1
diff --git a/test/IDE/Inputs/mock-sdk/Foo.printed.recursive.txt b/test/IDE/Inputs/mock-sdk/Foo.printed.recursive.txt
@@ -181,11 +181,16 @@ class FooClassDerived : FooClassBase, FooProtocolDerived {
   func fooProtoFuncWithExtraIndentation2()
   class func fooProtoClassFunc()
 }
+typealias typedef_int_t = Int32
 var FOO_MACRO_1: Int32 { get }
 var FOO_MACRO_2: Int32 { get }
 var FOO_MACRO_3: Int32 { get }
 var FOO_MACRO_4: UInt32 { get }
 var FOO_MACRO_5: UInt64 { get }
+var FOO_MACRO_6: typedef_int_t { get }
+var FOO_MACRO_7: typedef_int_t { get }
+var FOO_MACRO_OR: Int32 { get }
+var FOO_MACRO_AND: Int32 { get }
 var FOO_MACRO_REDEF_1: Int32 { get }
 var FOO_MACRO_REDEF_2: Int32 { get }
 func theLastDeclInFoo()
@@ -235,6 +240,8 @@ class FooClassWithClassProperties : FooClassBase {
   init!()
   convenience init!(float f: Float)
 }
+@available(*, unavailable, message: "use 'nil' instead of this imported macro")
+var FOO_NIL: ()
 class FooUnavailableMembers : FooClassBase {
   convenience init!(int i: Int32)
   @available(*, unavailable, message: "use object construction 'FooUnavailableMembers(int:)'")
diff --git a/test/IDE/Inputs/mock-sdk/Foo.printed.txt b/test/IDE/Inputs/mock-sdk/Foo.printed.txt
@@ -217,12 +217,18 @@ class FooClassDerived : FooClassBase, FooProtocolDerived {
   class func fooProtoClassFunc()
 }
 
+typealias typedef_int_t = Int32
+
 /* FOO_MACRO_1 is the answer */
 var FOO_MACRO_1: Int32 { get }
 var FOO_MACRO_2: Int32 { get }
 var FOO_MACRO_3: Int32 { get } // Don't use FOO_MACRO_3 on Saturdays.
 var FOO_MACRO_4: UInt32 { get }
 var FOO_MACRO_5: UInt64 { get }
+var FOO_MACRO_6: typedef_int_t { get }
+var FOO_MACRO_7: typedef_int_t { get }
+var FOO_MACRO_OR: Int32 { get }
+var FOO_MACRO_AND: Int32 { get }
 
 var FOO_MACRO_REDEF_1: Int32 { get }
 
@@ -286,6 +292,9 @@ class FooClassWithClassProperties : FooClassBase {
   convenience init!(float f: Float)
 }
 
+@available(*, unavailable, message: "use 'nil' instead of this imported macro")
+var FOO_NIL: ()
+
 class FooUnavailableMembers : FooClassBase {
   convenience init!(int i: Int32)
   @available(*, unavailable, message: "use object construction 'FooUnavailableMembers(int:)'")
diff --git a/test/IDE/complete_from_clang_framework.swift b/test/IDE/complete_from_clang_framework.swift
@@ -146,7 +146,7 @@ func testCompleteModuleQualifiedFoo2() {
   Foo#^CLANG_QUAL_FOO_2^#
 // If the number of results below changes, then you need to add a result to the
 // list below.
-// CLANG_QUAL_FOO_2: Begin completions, 64 items
+// CLANG_QUAL_FOO_2: Begin completions, 69 items
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .FooClassBase[#FooClassBase#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .FooClassDerived[#FooClassDerived#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .ClassWithInternalProt[#ClassWithInternalProt#]{{; name=.+$}}
@@ -176,6 +176,10 @@ func testCompleteModuleQualifiedFoo2() {
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_3[#Int32#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_4[#UInt32#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_5[#UInt64#]{{; name=.+$}}
+// CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_6[#typedef_int_t#]{{; name=.+$}}
+// CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_7[#typedef_int_t#]{{; name=.+$}}
+// CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_OR[#Int32#]{{; name=.+$}}
+// CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_AND[#Int32#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_REDEF_1[#Int32#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FOO_MACRO_REDEF_2[#Int32#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[GlobalVar]/OtherModule[Foo]:    .FooEnum1X[#FooEnum1#]{{; name=.+$}}
diff --git a/test/SourceKit/DocSupport/doc_clang_module.swift.response b/test/SourceKit/DocSupport/doc_clang_module.swift.response
