ClangImporter: enhance the importer to alias declarations

Import simple CPP macro aliases as aliases in Swift. Extend the macro
importer to import the following construct:

  ```
  #define alias aliasee
  ```

as the following Swift construct:

  ```
  @_transparent @inline(__always)
  var alias: type(of: aliasee) {
    aliasee
  }
  ```

This improves the QoI for Windows where there is a universal define
(`UNICODE`) which normally is used for translating APIs between ANSI and
Unicode variants, e.g.:

  ```
  #if defined(UNICODE)
  #define MessageBox MessageBoxW
  #else
  #define MessageBox MessageBoxA
  #endif
  ```

Author: compnerd

lib/ClangImporter/ImportMacro.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/DiagnosticsClangImporter.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/ParameterList.h"
 #include "swift/AST/Stmt.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
@@ -31,6 +32,7 @@
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DelayedDiagnostic.h"
+#include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
 #include "llvm/ADT/SmallString.h"
@@ -371,6 +373,59 @@ getIntegerConstantForMacroToken(ClangImporter::Implementation &impl,
   return std::nullopt;
 }
 
+namespace {
+ValueDecl *importDeclAlias(ClangImporter::Implementation &clang,
+                           swift::DeclContext *DC, const clang::ValueDecl *D,
+                           Identifier alias) {
+  swift::ValueDecl *VD =
+      dyn_cast_or_null<ValueDecl>(clang.importDecl(D, clang.CurrentVersion));
+  if (VD == nullptr)
+    return nullptr;
+
+  ImportedType Ty =
+      clang.importType(D->getType(), ImportTypeKind::Abstract,
+                       [&clang, &D](Diagnostic &&Diag) {
+                         clang.addImportDiagnostic(D, std::move(Diag),
+                                                   D->getLocation());
+                       }, /*AllowsNSUIntegerAsInt*/true,
+                       Bridgeability::None, { });
+  swift::Type AccessorTy = FunctionType::get({}, Ty.getType(), ASTExtInfo{});
+  swift::ASTContext &Ctx = DC->getASTContext();
+
+  /* Storage */
+  swift::VarDecl *V =
+      new (Ctx) VarDecl(/*IsStatic*/false, VarDecl::Introducer::Var,
+                        SourceLoc(), alias, DC);
+  V->setAccess(swift::AccessLevel::Public);
+  V->setInterfaceType(Ty.getType());
+  V->getAttrs().add(new (Ctx) TransparentAttr(/*Implicit*/true));
+  V->getAttrs().add(new (Ctx) InlineAttr(InlineKind::Always));
+
+  /* Accessor */
+  swift::AccessorDecl *G =
+      AccessorDecl::createImplicit(Ctx, AccessorKind::Get, V, false, false,
+                                   TypeLoc(), AccessorTy, DC);
+  G->setAccess(swift::AccessLevel::Public);
+  G->setInterfaceType(AccessorTy);
+  G->setParameters(ParameterList::create(Ctx, {}));
+  G->getAttrs().add(new (Ctx) TransparentAttr(/*Implicit*/true));
+
+  DeclRefExpr *DRE =
+      new (Ctx) DeclRefExpr(ConcreteDeclRef(VD), {}, /*Implicit*/true,
+                            AccessSemantics::Ordinary, Ty.getType());
+  ReturnStmt *RS = ReturnStmt::createImplicit(Ctx, DRE);
+
+  G->setBody(BraceStmt::createImplicit(Ctx, {RS}),
+             AbstractFunctionDecl::BodyKind::TypeChecked);
+
+  /* Bind */
+  V->setImplInfo(StorageImplInfo::getImmutableComputed());
+  V->setAccessors(SourceLoc(), {G}, SourceLoc());
+
+  return V;
+}
+}
+
 static ValueDecl *importMacro(ClangImporter::Implementation &impl,
                               llvm::SmallSet<StringRef, 4> &visitedMacros,
                               DeclContext *DC, Identifier name,
@@ -509,7 +564,14 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
         }
       }
 
-      // FIXME: If the identifier refers to a declaration, alias it?
+      /* Create an alias for any Decl */
+      clang::Sema &S = impl.getClangSema();
+      clang::LookupResult R(S, {{tok.getIdentifierInfo()}, {}},
+                            clang::Sema::LookupAnyName);
+      if (S.LookupName(R, S.TUScope))
+        if (R.getResultKind() == clang::LookupResult::LookupResultKind::Found)
+          if (const auto *VD = dyn_cast<clang::ValueDecl>(R.getFoundDecl()))
+            return importDeclAlias(impl, DC, VD, name);
     }
 
     // TODO(https://github.com/apple/swift/issues/57735): Seems rare to have a single token that is neither a literal nor an identifier, but add diagnosis.

test/ClangImporter/Inputs/custom-modules/Aliases.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#if defined(UNICODE)
+#define F FW
+#define V VW
+#else
+#define F FA
+#define V VA
+#endif
+
+extern const unsigned int VA;
+extern const unsigned long long VW;
+
+void FA(unsigned int);
+void FW(unsigned long long);
+
+#define InvalidCall DoesNotExist

test/ClangImporter/Inputs/custom-modules/module.modulemap

@@ -275,3 +275,7 @@ module CommonName {
 module "Weird C Module" {
   header "WeirdCModule.h"
 }
+
+module Aliases {
+  header "Aliases.h"
+}

test/ClangImporter/alias-invalid.swift

@@ -0,0 +1,8 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-typecheck-verify-swift -I %S/Inputs/custom-modules
+
+import Aliases
+
+func f() {
+  InvalidCall() // expected-error{{cannot find 'InvalidCall' in scope}}
+}

test/ClangImporter/alias.swift

@@ -0,0 +1,33 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-typcheck-verify-swift -I %S/Inputs/custom-modules %s
+// RUN: %target-swift-frontend -I %S/Inputs/custom-modules -parse-as-library -module-name Alias -Osize -emit-ir -o - %s | %FileCheck %s -check-prefix CHECK-ANSI-IR
+// RUN: %target-typecheck-verify-swift -I %S/Inputs/custom-modules %s -Xcc -DUNICODE
+// RUN: %target-swift-frontend -I %S/Inputs/custom-modules -parse-as-library -module-name Alias -Osize -emit-ir -o - %s -Xcc -DUNICODE | %FileCheck %s -check-prefix CHECK-UNICODE-IR
+
+// expected-no-diagnostics
+
+import Aliases
+
+func f() {
+  F(V)
+}
+
+// CHECK-ANSI-IR: define hidden swiftcc void @"$s5Alias1fyyF"(){{.*}}{
+// CHECK-ANSI-IR: entry:
+// CHECK-ANSI-IR:   %0 = load i32, ptr @VA, align 8
+// CHECK-ANSI-IR:   tail call void @FA(i32 %0)
+// CHECK-ANSI-IR:   ret void
+// CHECK-ANSI-IR: }
+
+// CHECK-ANSI-IR: declare dso_local void @FA(i32 noundef)
+// CHECK-ANSI-IR-NOT: declare dso_local void @FW(i64 noundef)
+
+// CHECK-UNICODE-IR: define hidden swiftcc void @"$s5Alias1fyyF"(){{.*}}{
+// CHECK-UNICODE-IR: entry:
+// CHECK-UNICODE-IR:   %0 = load i64, ptr @VW, align 8
+// CHECK-UNICODE-IR:   tail call void @FW(i64 %0)
+// CHECK-UNICODE-IR:   ret void
+// CHECK-UNICODE-IR: }
+
+// CHECK-UNICODE-IR: declare dso_local void @FW(i64 noundef)
+// CHECK-UNICODE-IR-NOT: declare dso_local void @FA(i32 noundef)