[ClangImporter] Import constant values for 'const' globals

Author: kubamracek

lib/ClangImporter/ImportDecl.cpp

@@ -4590,12 +4590,37 @@ namespace {
       auto introducer = Impl.shouldImportGlobalAsLet(decl->getType())
                         ? VarDecl::Introducer::Let
                         : VarDecl::Introducer::Var;
-      auto result = Impl.createDeclWithClangNode<VarDecl>(
-          decl, importer::convertClangAccess(decl->getAccess()),
-          /*IsStatic*/ isStatic, introducer,
-          Impl.importSourceLoc(decl->getLocation()), name, dc);
-      result->setIsObjC(false);
-      result->setIsDynamic(false);
+
+      ValueDecl *result = nullptr;
+
+      // If the variable is const (we're importing it as a let), and has an
+      // initializer, then ask Clang for its constant value and synthesize a
+      // getter with that value.
+      if (introducer == VarDecl::Introducer::Let && decl->hasInit()) {
+        auto val = decl->evaluateValue();
+        // For now, only import integer and float constants. If in the future
+        // SwiftDeclSynthesizer::createConstant becomes able to import more
+        // types, we can lift this restriction.
+        if (val && (val->isFloat() || val->isInt())) {
+          auto type = Impl.importTypeIgnoreIUO(
+              decl->getType(), ImportTypeKind::Value,
+              ImportDiagnosticAdder(Impl, decl, decl->getLocation()),
+              isInSystemModule(dc), Bridgeability::None, ImportTypeAttrs());
+          result = synthesizer.createConstant(
+              name, dc, type, *val, ConstantConvertKind::None, isStatic, decl,
+              importer::convertClangAccess(decl->getAccess()));
+        }
+      }
+
+      // Otherwise, import as an external declaration
+      if (!result) {
+        result = Impl.createDeclWithClangNode<VarDecl>(
+            decl, importer::convertClangAccess(decl->getAccess()),
+            /*IsStatic*/ isStatic, introducer,
+            Impl.importSourceLoc(decl->getLocation()), name, dc);
+        result->setIsObjC(false);
+        result->setIsDynamic(false);
+      }
 
       // If imported as member, the member should be final.
       if (dc->getSelfClassDecl())

test/ClangImporter/const_values.swift

@@ -0,0 +1,95 @@
+// RUN: %empty-directory(%t/src)
+// RUN: split-file %s %t/src
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck %t/src/main.swift \
+// RUN:   -import-bridging-header %t/src/test.h \
+// RUN:   -module-name main -I %t -emit-sil | %FileCheck %s
+
+//--- test.h
+#include <stdbool.h>
+
+#define MACRO_INT 42
+
+const int const_int = 42;
+static int static_int = 42;
+static const int static_const_int = 42;
+
+static const bool static_const_bool = true;
+static const char static_const_char = 42;
+static const long static_const_long = 42;
+static const float static_const_float = 42.0;
+static const double static_const_double = 42.0;
+
+//--- main.swift
+func foo() {
+  print(MACRO_INT)
+
+  print(const_int)
+  print(static_int)
+  print(static_const_int)
+
+  print(static_const_bool)
+  print(static_const_char)
+  print(static_const_long)
+  print(static_const_float)
+  print(static_const_double)
+}
+
+// Only 'static' cannot get the getter imported, because it's not guaranteed to be constant.
+// CHECK: sil_global public_external @static_int : $Int32
+
+// CHECK:      sil shared [transparent] @$sSC9MACRO_INTs5Int32Vvg : $@convention(thin) () -> Int32 {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int32, 42
+// CHECK-NEXT:   %1 = struct $Int32 (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo9const_ints5Int32Vvg : $@convention(thin) () -> Int32 {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int32, 42
+// CHECK-NEXT:   %1 = struct $Int32 (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo16static_const_ints5Int32Vvg : $@convention(thin) () -> Int32 {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int32, 42
+// CHECK-NEXT:   %1 = struct $Int32 (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo17static_const_boolSbvg : $@convention(thin) () -> Bool {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int1, -1
+// CHECK-NEXT:   %1 = struct $Bool (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo17static_const_chars4Int8Vvg : $@convention(thin) () -> Int8 {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int8, 42
+// CHECK-NEXT:   %1 = struct $Int8 (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo17static_const_longSivg : $@convention(thin) () -> Int {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = integer_literal $Builtin.Int64, 42
+// CHECK-NEXT:   %1 = struct $Int (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo18static_const_floatSfvg : $@convention(thin) () -> Float {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = float_literal $Builtin.FPIEEE32, 0x42280000 // 42
+// CHECK-NEXT:   %1 = struct $Float (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }
+
+// CHECK:      sil shared [transparent] @$sSo19static_const_doubleSdvg : $@convention(thin) () -> Double {
+// CHECK-NEXT: bb0:
+// CHECK-NEXT:   %0 = float_literal $Builtin.FPIEEE64, 0x4045000000000000 // 42
+// CHECK-NEXT:   %1 = struct $Double (%0)
+// CHECK-NEXT:   return %1
+// CHECK-NEXT: }