carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 21:41:27 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Fix crash when calling local function in generic function (#6912)

Browse Source 
Pass a function's self specific in `ScopeStack::PushForFunctionBody` and
remove assertion preventing lexical scopes from having specific IDs.
This allows lexical lookup within the function to find entities
associated with its self specific.

Closes #6793
This commit is contained in:
antangelo
2026-06-02 16:27:21 +00:00
committed by GitHub
parent b7f11e4c61
commit 8e477cc2c6
2 changed files with 108 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
toolchain/check/scope_stack.cpp
+14 -5
View File
@@ -72,9 +72,15 @@ auto ScopeStack::Push(SemIR::InstId scope_inst_id, SemIR::NameScopeId scope_id,
if (scope_stack_.back().is_lexical_scope()) {
// For lexical lookups, unqualified lookup doesn't know how to find the
// associated specific, so if we start adding lexical scopes associated with
// specifics, we'll need to somehow track them in lookup.
CARBON_CHECK(!specific_id.has_value(),
"Lexical scope should not have an associated specific.");
// specifics, we'll need to somehow track them in lookup. The self specific
// is an exception to this, as its generic will always lexically enclose the
// point of use of any looked up name.
CARBON_CHECK(!specific_id.has_value() ||
sem_ir().generics().GetSelfSpecific(
sem_ir().specifics().Get(specific_id).generic_id) ==
specific_id,
"Lexical scopes can only have an associated specific if it is "
"a self specific.");
} else {
non_lexical_scope_stack_.push_back({.scope_index = next_scope_index_,
.name_scope_id = scope_id,
@@ -111,8 +117,11 @@ auto ScopeStack::PushForSameRegion() -> void {
}
auto ScopeStack::PushForFunctionBody(SemIR::InstId scope_inst_id) -> void {
CARBON_DCHECK(sem_ir().insts().Is<SemIR::FunctionDecl>(scope_inst_id));
Push(scope_inst_id, SemIR::NameScopeId::None, SemIR::SpecificId::None,
const auto& function_decl =
sem_ir().insts().GetAs<SemIR::FunctionDecl>(scope_inst_id);
const auto& function = sem_ir().functions().Get(function_decl.function_id);
auto self_specific = sem_ir().generics().GetSelfSpecific(function.generic_id);
Push(scope_inst_id, SemIR::NameScopeId::None, self_specific,
/*lexical_lookup_has_load_error=*/false);
return_scope_stack_.push_back({.decl_id = scope_inst_id});
toolchain/check/testdata/generic/local_function.carbon
Vendored
+94
View File
@@ -0,0 +1,94 @@
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
// INCLUDE-FILE: toolchain/testing/testdata/min_prelude/int.carbon
// TODO: Add ranges and switch to "--dump-sem-ir-ranges=only".
// EXTRA-ARGS: --dump-sem-ir-ranges=if-present
//
// AUTOUPDATE
// TIP: To test this file alone, run:
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/generic/local_function.carbon
// TIP: To dump output, run:
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/generic/local_function.carbon
fn Test[unused T:! type]() {
fn Local() {
}
Local();
}
// CHECK:STDOUT: --- local_function.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %type: type = facet_type <type> [concrete]
// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self]
// CHECK:STDOUT: %pattern_type: type = pattern_type type [concrete]
// CHECK:STDOUT: %T: type = symbolic_binding T, 0 [symbolic]
// CHECK:STDOUT: %Test.type: type = fn_type @Test [concrete]
// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [concrete]
// CHECK:STDOUT: %Test: %Test.type = struct_value () [concrete]
// CHECK:STDOUT: %Local.type: type = fn_type @Local, @Test(%T) [symbolic]
// CHECK:STDOUT: %Local: %Local.type = struct_value () [symbolic]
// CHECK:STDOUT: %Local.specific_fn: <specific function> = specific_function %Local, @Local(%T) [symbolic]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: imports {
// CHECK:STDOUT: %Core: <namespace> = namespace file.%Core.import, [concrete] {
// CHECK:STDOUT: import Core//prelude
// CHECK:STDOUT: import Core//prelude/...
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
// CHECK:STDOUT: package: <namespace> = namespace [concrete] {
// CHECK:STDOUT: .Core = imports.%Core
// CHECK:STDOUT: .Test = %Test.decl
// CHECK:STDOUT: }
// CHECK:STDOUT: %Core.import = import Core
// CHECK:STDOUT: %Test.decl: %Test.type = fn_decl @Test [concrete = constants.%Test] {
// CHECK:STDOUT: %T.patt: %pattern_type = symbolic_binding_pattern T, 0 [concrete]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc15_20.1: type = splice_block %.loc15_20.2 [concrete = type] {
// CHECK:STDOUT: %.Self: %type = symbolic_binding .Self [symbolic_self = constants.%.Self]
// CHECK:STDOUT: %.loc15_20.2: type = type_literal type [concrete = type]
// CHECK:STDOUT: }
// CHECK:STDOUT: %T.loc15_17.2: type = symbolic_binding T, 0 [symbolic = %T.loc15_17.1 (constants.%T)]
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Test(%T.loc15_17.2: type) {
// CHECK:STDOUT: %T.loc15_17.1: type = symbolic_binding T, 0 [symbolic = %T.loc15_17.1 (constants.%T)]
// CHECK:STDOUT:
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: %Local.type: type = fn_type @Local, @Test(%T.loc15_17.1) [symbolic = %Local.type (constants.%Local.type)]
// CHECK:STDOUT: %Local: @Test.%Local.type (%Local.type) = struct_value () [symbolic = %Local (constants.%Local)]
// CHECK:STDOUT: %Local.specific_fn.loc18_3.2: <specific function> = specific_function %Local, @Local(%T.loc15_17.1) [symbolic = %Local.specific_fn.loc18_3.2 (constants.%Local.specific_fn)]
// CHECK:STDOUT:
// CHECK:STDOUT: fn() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %Local.decl: @Test.%Local.type (%Local.type) = fn_decl @Local [symbolic = @Test.%Local (constants.%Local)] {} {}
// CHECK:STDOUT: %Local.ref: @Test.%Local.type (%Local.type) = name_ref Local, %Local.decl [symbolic = %Local (constants.%Local)]
// CHECK:STDOUT: %Local.specific_fn.loc18_3.1: <specific function> = specific_function %Local.ref, @Local(constants.%T) [symbolic = %Local.specific_fn.loc18_3.2 (constants.%Local.specific_fn)]
// CHECK:STDOUT: %Local.call: init %empty_tuple.type = call %Local.specific_fn.loc18_3.1()
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: generic fn @Local(@Test.%T.loc15_17.2: type) {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT:
// CHECK:STDOUT: fn() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Test(constants.%T) {
// CHECK:STDOUT: %T.loc15_17.1 => constants.%T
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: specific @Local(constants.%T) {
// CHECK:STDOUT: !definition:
// CHECK:STDOUT: }
// CHECK:STDOUT: