Merge pull request #3604 from eeckstein/clang-import

SIL: Print+parse the clang node owner of SILFunctions.

Author: eeckstein

lib/Parse/ParseSIL.cpp

@@ -239,6 +239,12 @@ namespace {
       SmallVector<ValueDecl *, 4> values;
       return parseSILDottedPath(Decl, values);
     }
+    bool parseSILDottedPathWithoutPound(ValueDecl *&Decl,
+                                        SmallVectorImpl<ValueDecl *> &values);
+    bool parseSILDottedPathWithoutPound(ValueDecl *&Decl) {
+      SmallVector<ValueDecl *, 4> values;
+      return parseSILDottedPathWithoutPound(Decl, values);
+    }
     /// At the time of calling this function, we may not have the type of the
     /// Decl yet. So we return a SILDeclRef on the first lookup result and also
     /// return all the lookup results. After parsing the expected type, the
@@ -676,75 +682,83 @@ static bool parseDeclSILOptional(bool *isTransparent, bool *isFragile,
                                  Inline_t *inlineStrategy, bool *isLet,
                                  SmallVectorImpl<std::string> *Semantics,
                                  SmallVectorImpl<ParsedSpecAttr> *SpecAttrs,
-                                 EffectsKind *MRK, Parser &P) {
-  while (P.consumeIf(tok::l_square)) {
-    if (isLet && P.Tok.is(tok::kw_let)) {
+                                 ValueDecl **ClangDecl,
+                                 EffectsKind *MRK, SILParser &SP) {
+  while (SP.P.consumeIf(tok::l_square)) {
+    if (isLet && SP.P.Tok.is(tok::kw_let)) {
       *isLet = true;
-      P.consumeToken(tok::kw_let);
-      P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+      SP.P.consumeToken(tok::kw_let);
+      SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
       continue;
     }
-    else if (P.Tok.isNot(tok::identifier)) {
-      P.diagnose(P.Tok, diag::expected_in_attribute_list);
+    else if (SP.P.Tok.isNot(tok::identifier)) {
+      SP.P.diagnose(SP.P.Tok, diag::expected_in_attribute_list);
       return true;
-    } else if (isTransparent && P.Tok.getText() == "transparent")
+    } else if (isTransparent && SP.P.Tok.getText() == "transparent")
       *isTransparent = true;
-    else if (isFragile && P.Tok.getText() == "fragile")
+    else if (isFragile && SP.P.Tok.getText() == "fragile")
       *isFragile = true;
-    else if (isThunk && P.Tok.getText() == "thunk")
+    else if (isThunk && SP.P.Tok.getText() == "thunk")
       *isThunk = IsThunk;
-    else if (isThunk && P.Tok.getText() == "reabstraction_thunk")
+    else if (isThunk && SP.P.Tok.getText() == "reabstraction_thunk")
       *isThunk = IsReabstractionThunk;
-    else if (isGlobalInit && P.Tok.getText() == "global_init")
+    else if (isGlobalInit && SP.P.Tok.getText() == "global_init")
       *isGlobalInit = true;
-    else if (inlineStrategy && P.Tok.getText() == "noinline")
+    else if (inlineStrategy && SP.P.Tok.getText() == "noinline")
       *inlineStrategy = NoInline;
-    else if (inlineStrategy && P.Tok.getText() == "always_inline")
+    else if (inlineStrategy && SP.P.Tok.getText() == "always_inline")
       *inlineStrategy = AlwaysInline;
-    else if (MRK && P.Tok.getText() == "readnone")
+    else if (MRK && SP.P.Tok.getText() == "readnone")
       *MRK = EffectsKind::ReadNone;
-    else if (MRK && P.Tok.getText() == "readonly")
+    else if (MRK && SP.P.Tok.getText() == "readonly")
       *MRK = EffectsKind::ReadOnly;
-    else if (MRK && P.Tok.getText() == "readwrite")
+    else if (MRK && SP.P.Tok.getText() == "readwrite")
       *MRK = EffectsKind::ReadWrite;
-    else if (Semantics && P.Tok.getText() == "_semantics") {
-      P.consumeToken(tok::identifier);
-      if (P.Tok.getKind() != tok::string_literal) {
-        P.diagnose(P.Tok, diag::expected_in_attribute_list);
+    else if (Semantics && SP.P.Tok.getText() == "_semantics") {
+      SP.P.consumeToken(tok::identifier);
+      if (SP.P.Tok.getKind() != tok::string_literal) {
+        SP.P.diagnose(SP.P.Tok, diag::expected_in_attribute_list);
         return true;
       }
 
       // Drop the double quotes.
-      StringRef rawString = P.Tok.getText().drop_front().drop_back();
+      StringRef rawString = SP.P.Tok.getText().drop_front().drop_back();
       Semantics->push_back(rawString);
-      P.consumeToken(tok::string_literal);
+      SP.P.consumeToken(tok::string_literal);
 
-      P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+      SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
       continue;
     }
-    else if (SpecAttrs && P.Tok.getText() == "_specialize") {
-      P.consumeToken(tok::identifier);
+    else if (SpecAttrs && SP.P.Tok.getText() == "_specialize") {
+      SP.P.consumeToken(tok::identifier);
 
       /// Parse a specialized attributed, building a parsed substitution list
       /// and pushing a new ParsedSpecAttr on the SpecAttrs list. Conformances
       /// cannot be generated until the function declaration is fully parsed so
       /// that the function's generic signature can be consulted.
-      SILParser SpecAttrState(P);
       ParsedSpecAttr SpecAttr;
-      if (SpecAttrState.parseApplySubstitutions(SpecAttr.subs))
+      if (SP.parseApplySubstitutions(SpecAttr.subs))
         return true;
 
       SpecAttrs->emplace_back(SpecAttr);
 
-      P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+      SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+      continue;
+    }
+    else if (ClangDecl && SP.P.Tok.getText() == "clang") {
+      SP.P.consumeToken(tok::identifier);
+      if (SP.parseSILDottedPathWithoutPound(*ClangDecl))
+        return true;
+
+      SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
       continue;
     }
     else {
-      P.diagnose(P.Tok, diag::expected_in_attribute_list);
+      SP.P.diagnose(SP.P.Tok, diag::expected_in_attribute_list);
       return true;
     }
-    P.consumeToken(tok::identifier);
-    P.parseToken(tok::r_square, diag::expected_in_attribute_list);
+    SP.P.consumeToken(tok::identifier);
+    SP.P.parseToken(tok::r_square, diag::expected_in_attribute_list);
   }
   return false;
 }
@@ -875,7 +889,11 @@ bool SILParser::parseSILDottedPath(ValueDecl *&Decl,
                                    SmallVectorImpl<ValueDecl *> &values) {
   if (P.parseToken(tok::pound, diag::expected_sil_constant))
     return true;
+  return parseSILDottedPathWithoutPound(Decl, values);
+}
 
+bool SILParser::parseSILDottedPathWithoutPound(ValueDecl *&Decl,
+                                   SmallVectorImpl<ValueDecl *> &values) {
   // Handle sil-dotted-path.
   Identifier Id;
   SmallVector<Identifier, 4> FullName;
@@ -3858,11 +3876,12 @@ bool Parser::parseDeclSIL() {
   Inline_t inlineStrategy = InlineDefault;
   SmallVector<std::string, 1> Semantics;
   SmallVector<ParsedSpecAttr, 4> SpecAttrs;
+  ValueDecl *ClangDecl = nullptr;
   EffectsKind MRK = EffectsKind::Unspecified;
   if (parseSILLinkage(FnLinkage, *this) ||
       parseDeclSILOptional(&isTransparent, &isFragile, &isThunk, &isGlobalInit,
                            &inlineStrategy, nullptr, &Semantics, &SpecAttrs,
-                           &MRK, *this) ||
+                           &ClangDecl, &MRK, FunctionState) ||
       parseToken(tok::at_sign, diag::expected_sil_function_name) ||
       parseIdentifier(FnName, FnNameLoc, diag::expected_sil_function_name) ||
       parseToken(tok::colon, diag::expected_sil_type))
@@ -3889,6 +3908,8 @@ bool Parser::parseDeclSIL() {
     FunctionState.F->setGlobalInit(isGlobalInit);
     FunctionState.F->setInlineStrategy(inlineStrategy);
     FunctionState.F->setEffectsKind(MRK);
+    if (ClangDecl)
+      FunctionState.F->setClangNodeOwner(ClangDecl);
     for (auto &Attr : Semantics) {
       FunctionState.F->addSemanticsAttr(Attr);
     }
@@ -3997,15 +4018,16 @@ bool Parser::parseSILGlobal() {
   // Inform the lexer that we're lexing the body of the SIL declaration.
   Lexer::SILBodyRAII Tmp(*L);
   Scope S(this, ScopeKind::TopLevel);
+  SILParser State(*this);
   if (parseSILLinkage(GlobalLinkage, *this) ||
       parseDeclSILOptional(nullptr, &isFragile, nullptr, nullptr,
-                           nullptr, &isLet, nullptr, nullptr, nullptr, *this) ||
+                           nullptr, &isLet, nullptr, nullptr, nullptr,
+                           nullptr, State) ||
       parseToken(tok::at_sign, diag::expected_sil_value_name) ||
       parseIdentifier(GlobalName, NameLoc, diag::expected_sil_value_name) ||
       parseToken(tok::colon, diag::expected_sil_type))
     return true;
 
-  SILParser State(*this);
   if (State.parseSILType(GlobalType))
     return true;
 
@@ -4342,7 +4364,8 @@ bool Parser::parseSILWitnessTable() {
 
   bool isFragile = false;
   if (parseDeclSILOptional(nullptr, &isFragile, nullptr, nullptr,
-                           nullptr, nullptr, nullptr, nullptr, nullptr, *this))
+                           nullptr, nullptr, nullptr, nullptr, nullptr,
+                           nullptr, WitnessState))
     return true;
 
   Scope S(this, ScopeKind::TopLevel);

lib/SIL/SILPrinter.cpp

@@ -229,6 +229,16 @@ static void printFullContext(const DeclContext *Context, raw_ostream &Buffer) {
   llvm_unreachable("bad decl context");
 }
 
+static void printValueDecl(ValueDecl *Decl, raw_ostream &OS) {
+  printFullContext(Decl->getDeclContext(), OS);
+  assert(Decl->hasName());
+
+  if (Decl->isOperator())
+    OS << '"' << Decl->getName() << '"';
+  else
+    OS << Decl->getName();
+}
+
 /// SILDeclRef uses sigil "#" and prints the fully qualified dotted path.
 void SILDeclRef::print(raw_ostream &OS) const {
   OS << "#";
@@ -242,53 +252,42 @@ void SILDeclRef::print(raw_ostream &OS) const {
     OS << "<anonymous function>";
   } else if (kind == SILDeclRef::Kind::Func) {
     auto *FD = cast<FuncDecl>(getDecl());
-    ValueDecl *decl = FD;
-    const char *Suffix;
     switch (FD->getAccessorKind()) {
     case AccessorKind::IsWillSet:
-      Suffix = "!willSet";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!willSet";
       break;
     case AccessorKind::IsDidSet:
-      Suffix = "!didSet";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!didSet";
       break;
     case AccessorKind::NotAccessor:
-      Suffix = "";
+      printValueDecl(FD, OS);
       isDot = false;
       break;
     case AccessorKind::IsGetter:
-      Suffix = "!getter";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!getter";
       break;
     case AccessorKind::IsSetter:
-      Suffix = "!setter";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!setter";
       break;
     case AccessorKind::IsMaterializeForSet:
-      Suffix = "!materializeForSet";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!materializeForSet";
       break;
     case AccessorKind::IsAddressor:
-      Suffix = "!addressor";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!addressor";
       break;
     case AccessorKind::IsMutableAddressor:
-      Suffix = "!mutableAddressor";
-      decl = FD->getAccessorStorageDecl();
+      printValueDecl(FD->getAccessorStorageDecl(), OS);
+      OS << "!mutableAddressor";
       break;
     }
-
-    printFullContext(decl->getDeclContext(), OS);
-    assert(decl->hasName());
-
-    if (decl->isOperator())
-      OS << '"' << decl->getName() << '"' << Suffix;
-    else
-      OS << decl->getName() << Suffix;
   } else {
-    printFullContext(getDecl()->getDeclContext(), OS);
-    OS << getDecl()->getName();
+    printValueDecl(getDecl(), OS);
   }
   switch (kind) {
   case SILDeclRef::Kind::Func:
@@ -1748,6 +1747,14 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
   for (auto *Attr : getSpecializeAttrs()) {
     OS << "[_specialize "; Attr->print(OS); OS << "] ";
   }
+
+  // TODO: Handle clang node owners which don't have a name.
+  if (hasClangNode() && getClangNodeOwner()->hasName()) {
+    OS << "[clang ";
+    printValueDecl(getClangNodeOwner(), OS);
+    OS << "] ";
+  }
+
   printName(OS);
   OS << " : $";
 

test/ClangModules/Inputs/static_inline.h

@@ -0,0 +1,5 @@
+
+static inline int c_inline_func(int x) {
+  return x + 27;
+}
+

test/ClangModules/const_and_pure.swift

@@ -8,8 +8,8 @@ func testit() {
 	normal_function()
 }
 
-// CHECK: sil [readnone] @const_function : $@convention(c) () -> ()
-// CHECK: sil [readonly] @pure_function : $@convention(c) () -> ()
-// CHECK: sil @normal_function : $@convention(c) () -> ()
+// CHECK: sil [readnone] [clang const_function] @const_function : $@convention(c) () -> ()
+// CHECK: sil [readonly] [clang pure_function] @pure_function : $@convention(c) () -> ()
+// CHECK: sil [clang normal_function] @normal_function : $@convention(c) () -> ()
 
 

test/ClangModules/static_inline.swift

@@ -0,0 +1,17 @@
+// RUN: rm -rf %t && mkdir -p %t
+
+// Check if SIL printing+parsing of a clang imported function works.
+
+// RUN: %target-swift-frontend -parse-as-library -module-name=test -emit-sil %s -import-objc-header %S/Inputs/static_inline.h -o %t/test.sil
+// RUN: FileCheck < %t/test.sil %s
+// RUN: %target-swift-frontend -parse-as-library -module-name=test -O -emit-ir %t/test.sil -import-objc-header %S/Inputs/static_inline.h | FileCheck --check-prefix=CHECK-IR %s
+
+// CHECK: sil shared [clang c_inline_func] @c_inline_func : $@convention(c) (Int32) -> Int32
+
+// CHECK-IR-LABEL: define{{.*}} i32 @_TF4test6testitFT1xVs5Int32_S0_(i32)
+// CHECK-IR: = add {{.*}}, 27
+// CHECK-IR: ret
+
+public func testit(x: Int32) -> Int32 {
+  return c_inline_func(x)
+}