1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
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
}
|
