[Compile Time Values] Rewrite the 'Diagnose Unknown Compile Time Values' diagnostic pass in Swift

Author: artemcm

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -83,7 +83,9 @@ final public class AssociatedTypeDecl: TypeDecl {}
 
 final public class ModuleDecl: TypeDecl {}
 
-public class AbstractStorageDecl: ValueDecl {}
+public class AbstractStorageDecl: ValueDecl {
+  final public var isConst: Bool { bridged.AbstractStorage_isConst() }
+}
 
 public class VarDecl: AbstractStorageDecl {}
 

SwiftCompilerSources/Sources/Optimizer/ModulePasses/CMakeLists.txt

@@ -7,6 +7,7 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
+  DiagnoseUnknownConstValues.swift
   MandatoryPerformanceOptimizations.swift
   ReadOnlyGlobalVariables.swift
   StackProtection.swift

SwiftCompilerSources/Sources/Optimizer/ModulePasses/DiagnoseUnknownConstValues.swift

@@ -0,0 +1,103 @@
+//===--------- DiagnoseUnknownConstValues.swift --------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+import AST
+
+/// Performs mandatory diagnostic pass for emitting errors for '@const' values which the compiler was not able to
+/// simplify/interpret/reduce to a symbolic value.
+///
+let diagnoseUnknownConstValues = ModulePass(name: "diagnose-unknown-const-values") {
+  (moduleContext: ModulePassContext) in
+  var constExprEvaluator: ConstExpressionEvaluator = .init()
+  defer { constExprEvaluator.deinitialize() }
+  
+  // Verify all const globals to be initialized with compile-time known values
+  verifyGlobals(moduleContext)
+  
+  // Verify @const lets appearing as local variables
+  verifyLocals(constExprEvaluator: &constExprEvaluator,
+               moduleContext)
+  
+  // For each function call, ensure arguments to @const parameters are all compile-time known values
+  verifyCallArguments(constExprEvaluator: &constExprEvaluator,
+                      moduleContext)
+  
+  // For each `@const` function, ensure it is fully evaluable/interpretable at compile time
+  verifyFunctions(moduleContext)
+}
+
+private func verifyGlobals(_ context: ModulePassContext) {
+  for gv in context.globalVariables where gv.isConst {
+    if gv.staticInitValue == nil {
+      context.diagnosticEngine.diagnose(gv.varDecl?.location.sourceLoc,
+                                        .require_const_initializer_for_const)
+    }
+  }
+}
+
+private func verifyLocals(constExprEvaluator: inout ConstExpressionEvaluator,
+                          _ context: ModulePassContext) {
+  for f in context.functions {
+    for i in f.instructions {
+      if let dbi = i as? DebugValueInst {
+        verifyLocal(debugValueInst: dbi, constExprState: &constExprEvaluator, in: context)
+      }
+    }
+  }
+}
+
+private func verifyLocal(debugValueInst: DebugValueInst,
+                         constExprState: inout ConstExpressionEvaluator,
+                         in context: ModulePassContext) {
+  guard let localVarDecl = debugValueInst.varDecl,
+        !(localVarDecl is ParamDecl),
+        localVarDecl.isConst else {
+    return
+  }
+  
+  if !constExprState.isConstantValue(debugValueInst.operand.value) {
+    context.diagnosticEngine.diagnose(debugValueInst.location.sourceLoc,
+                                      .require_const_initializer_for_const)
+  }
+}
+
+private func verifyCallArguments(constExprEvaluator: inout ConstExpressionEvaluator,
+                                 _ context: ModulePassContext) {
+  for f in context.functions {
+    for i in f.instructions {
+      // TODO: Consider closures (partial_apply)
+      if let apply = i as? FullApplySite {
+        verifyCallArguments(apply: apply, constExprState: &constExprEvaluator, in: context)
+      }
+    }
+  }
+}
+
+private func verifyCallArguments(apply: FullApplySite,
+                                 constExprState: inout ConstExpressionEvaluator,
+                                 in context: ModulePassContext) {
+  guard let calleeFn = apply.referencedFunction else {
+    return
+  }
+  for (paramIdx, param) in calleeFn.convention.parameters.enumerated() where param.hasOption(.const) {
+    let matchingOperand = apply.parameterOperands[paramIdx]
+    if !constExprState.isConstantValue(matchingOperand.value) {
+      context.diagnosticEngine.diagnose(apply.location.sourceLoc,
+                                        .require_const_arg_for_parameter)
+    }
+  }
+}
+
+private func verifyFunctions(_ context: ModulePassContext) {
+  // TODO: Implement
+}

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -35,8 +35,7 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
   if moduleContext.options.enableEmbeddedSwift {
     worklist.addAllNonGenericFunctions(of: moduleContext)
   } else {
-    worklist.addAllPerformanceAnnotatedFunctions(of: moduleContext)
-    worklist.addAllAnnotatedGlobalInitOnceFunctions(of: moduleContext)
+    worklist.addAllMandatoryRequiredFunctions(of: moduleContext)
   }
 
   optimizeFunctionsTopDown(using: &worklist, moduleContext)
@@ -47,15 +46,6 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
   }
 }
 
-/// Performance the same set of top-down optimization as the above "mandatory-performance-optimizations"
-/// pass, but only on the initializers of '@const' globals.
-let constGlobalVariableFoldingPass = ModulePass(name: "const-global-variable-folding") {
-  (moduleContext: ModulePassContext) in
-  var worklist = FunctionWorklist()
-  worklist.addAllConstGlobalInitOnceFunctions(of: moduleContext)
-  optimizeFunctionsTopDown(using: &worklist, moduleContext)
-}
-
 private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
                                       _ moduleContext: ModulePassContext) {
   while let f = worklist.pop() {
@@ -492,10 +482,29 @@ fileprivate struct FunctionWorklist {
     }
     return nil
   }
-
-  mutating func addAllPerformanceAnnotatedFunctions(of moduleContext: ModulePassContext) {
-    for f in moduleContext.functions where f.performanceConstraints != .none {
-      pushIfNotVisited(f)
+  
+  mutating func addAllMandatoryRequiredFunctions(of moduleContext: ModulePassContext) {
+    for f in moduleContext.functions {
+      // Performance annotated functions
+      if f.performanceConstraints != .none {
+        pushIfNotVisited(f)
+      }
+      
+      // Annotated global init-once functions
+      if f.isGlobalInitOnceFunction {
+        if let global = f.getInitializedGlobal(),
+           global.mustBeInitializedStatically {
+          pushIfNotVisited(f)
+        }
+      }
+      
+      // @const global init-once functions
+      if f.isGlobalInitOnceFunction {
+        if let global = f.getInitializedGlobal(),
+           global.mustBeInitializedStatically {
+          pushIfNotVisited(f)
+        }
+      }
     }
   }
 
@@ -506,24 +515,6 @@ fileprivate struct FunctionWorklist {
     return
   }
 
-  mutating func addAllAnnotatedGlobalInitOnceFunctions(of moduleContext: ModulePassContext) {
-    for f in moduleContext.functions where f.isGlobalInitOnceFunction {
-      if let global = f.getInitializedGlobal(),
-         global.mustBeInitializedStatically {
-        pushIfNotVisited(f)
-      }
-    }
-  }
-
-  mutating func addAllConstGlobalInitOnceFunctions(of moduleContext: ModulePassContext) {
-    for f in moduleContext.functions where f.isGlobalInitOnceFunction {
-      if let global = f.getInitializedGlobal(),
-         global.isConst {
-        pushIfNotVisited(f)
-      }
-    }
-  }
-
   mutating func addCallees(of function: Function) {
     for inst in function.instructions {
       switch inst {

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -64,7 +64,7 @@ private func registerForSILCombine<InstType: SILCombineSimplifiable>(
 private func registerSwiftPasses() {
   // Module passes
   registerPass(mandatoryPerformanceOptimizations, { mandatoryPerformanceOptimizations.run($0) })
-  registerPass(constGlobalVariableFoldingPass, { constGlobalVariableFoldingPass.run($0)})
+  registerPass(diagnoseUnknownConstValues, { diagnoseUnknownConstValues.run($0)})
   registerPass(readOnlyGlobalVariablesPass, { readOnlyGlobalVariablesPass.run($0) })
   registerPass(stackProtection, { stackProtection.run($0) })
 

SwiftCompilerSources/Sources/SIL/CMakeLists.txt

@@ -16,6 +16,7 @@ add_swift_compiler_module(SIL
     ASTExtensions.swift
     BasicBlock.swift
     Builder.swift
+    ConstExpressionEvaluator.swift
     DeclRef.swift
     Effects.swift
     ForwardingInstruction.swift

SwiftCompilerSources/Sources/SIL/ConstExpressionEvaluator.swift

@@ -0,0 +1,32 @@
+//===--- ConstExpressionEvaluator.swift - ---------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import AST
+import SILBridging
+
+public struct ConstExpressionEvaluator {
+  var bridged: BridgedConstExprFunctionState
+
+  public init(bridged: BridgedConstExprFunctionState) { self.bridged = bridged }
+  public init() {
+    self.bridged = BridgedConstExprFunctionState.create()
+  }
+  
+  mutating public func isConstantValue(_ value: Value) -> Bool {
+    return bridged.isConstantValue(value.bridged)
+  }
+  
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating public func deinitialize() {
+    bridged.deinitialize()
+  }
+}

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -163,6 +163,15 @@ public struct ParameterInfo : CustomStringConvertible {
   public let convention: ArgumentConvention
   public let options: UInt8
   public let hasLoweredAddresses: Bool
+  
+  // Must be kept consistent with 'SILParameterInfo::Flag'
+  public enum Flag : UInt8 {
+    case notDifferentiable = 0x1
+    case sending = 0x2
+    case isolated = 0x4
+    case implicitLeading = 0x8
+    case const = 0x10
+  };
 
   public init(type: CanonicalType, convention: ArgumentConvention, options: UInt8, hasLoweredAddresses: Bool) {
     self.type = type
@@ -193,6 +202,10 @@ public struct ParameterInfo : CustomStringConvertible {
   public var description: String {
     "\(convention): \(type)"
   }
+  
+  public func hasOption(_ flag: Flag) -> Bool {
+    return options & flag.rawValue != 0
+  }
 }
 
 extension FunctionConvention {

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -72,7 +72,11 @@ final public class GlobalVariable : CustomStringConvertible, HasShortDescription
   }
 
   public var isConst: Bool {
-    return bridged.isConstVal()
+    return bridged.isConstValue()
+  }
+  
+  public var sourceLocation: SourceLoc? {
+    return SourceLoc(bridged: bridged.getSourceLocation())
   }
 
   public static func ==(lhs: GlobalVariable, rhs: GlobalVariable) -> Bool {

include/swift/AST/ASTBridging.h

@@ -384,6 +384,7 @@ struct BridgedDeclObj {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedSourceLoc Value_getNameLoc() const;
   BRIDGED_INLINE bool hasClangNode() const;
   BRIDGED_INLINE bool Value_isObjC() const;
+  BRIDGED_INLINE bool AbstractStorage_isConst() const;
   BRIDGED_INLINE bool GenericType_isGenericAtAnyLevel() const;
   BRIDGED_INLINE bool NominalType_isGlobalActor() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedDeclObj NominalType_getValueTypeDestructor() const;