mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-04 14:41:04 +01:00
Chandler Carruth
8be274cf60
Implement the toolchain side of proposal #7254, removing the `:!` binding syntax for generic and template parameters in favor of the keywords `generic`, `template`, and `runtime` plus contextual defaults for phase. For valid programs this is semantics-preserving: each binding resolves to the same phase, and produces the same SemIR, as it did under `:!`/`:`. The parser derives a binding's phase from its syntactic context plus any explicit phase keyword; new diagnostics and error recovery for misused keywords are described below. Implementation details for each component: - Lexer: remove the `:!` (`ColonExclaim`) token, move its virtual parse-node budget onto `:`, and add the `generic` and `runtime` keywords. - Parser: thread a `BindingContext` (`ExplicitParam`, `DeducedParam`, or `CompileTimeEntityParam`) from declaration introducers down through parameter lists to each binding pattern, using a one-token lookahead to distinguish a name-qualifier parameter list from a declaration's own final list. Parameters of a compile-time entity (`class`, `interface`, `constraint`, `choice`, `alias`, `export`, `namespace`) and deduced `[]` parameters default to checked generic; explicit function parameters and local bindings default to runtime. `HandleBindingPattern` resolves the phase from that context plus the keyword: a `generic` keyword needs no node of its own (the phase is carried by the binding's node kind), while a `runtime` keyword is preserved as a `RuntimeBindingName` node so `check` can name it in a diagnostic. A phase keyword that is merely redundant with the contextual default is diagnosed here, without invalidating the parse tree. - Check: a phase keyword that is invalid for its context (for example `runtime` on a checked-generic parameter) is diagnosed here, and recovers by building an error binding that still introduces the name so that later uses of it do not produce cascading errors. The removed `:!` syntax is now rejected as an ordinary parse error. The `form`/`:?`/`->?` ("extended types") portion of proposal #7254 is left for a separate change. Assisted-by: Claude Code
355 lines
11 KiB
Plaintext
355 lines
11 KiB
Plaintext
// 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/primitives.carbon
|
|
//
|
|
// AUTOUPDATE
|
|
// TIP: To test this file alone, run:
|
|
// TIP: bazel test //toolchain/testing:file_test --test_arg=--file_tests=toolchain/check/testdata/patterns/unused.carbon
|
|
// TIP: To dump output, run:
|
|
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/patterns/unused.carbon
|
|
|
|
// --- todo_ensure_no_warning.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn ReturnVar() -> i32 {
|
|
var x: i32 = 0;
|
|
x = 1;
|
|
return x;
|
|
}
|
|
|
|
fn ReturnLet() -> i32 {
|
|
let y: i32 = 1;
|
|
return y;
|
|
}
|
|
|
|
fn RefParam(ref x: i32) {
|
|
x = 1;
|
|
}
|
|
|
|
fn ReturnedVar() -> i32 {
|
|
returned var x: i32 = 0;
|
|
return var;
|
|
}
|
|
|
|
fn ReturnVarExplicit() -> i32 {
|
|
var x: i32 = 0;
|
|
return x;
|
|
}
|
|
|
|
fn FieldAccess() {
|
|
var x: {.a: i32} = {.a = 0};
|
|
// Accessing a field should count as a use of x.
|
|
var _: i32 = x.a;
|
|
}
|
|
|
|
fn ParametersUsed(x: i32) -> i32 {
|
|
return x;
|
|
}
|
|
|
|
// --- unused_ref_param.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn RefParamUnused(unused ref y: i32) {
|
|
}
|
|
|
|
// --- local_let_named_not_used.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
// CHECK:STDERR: local_let_named_not_used.carbon:[[@LINE+4]]:7: warning: binding `x` unused [UnusedBinding]
|
|
// CHECK:STDERR: let x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
let x: i32 = 0;
|
|
}
|
|
|
|
// --- local_var_named_not_used.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
// CHECK:STDERR: local_var_named_not_used.carbon:[[@LINE+4]]:7: warning: binding `a` unused [UnusedBinding]
|
|
// CHECK:STDERR: var a: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var a: i32 = 0;
|
|
}
|
|
|
|
// --- local_var_shadowed_not_used.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
var x: i32 = 0;
|
|
if (true) {
|
|
// CHECK:STDERR: local_var_shadowed_not_used.carbon:[[@LINE+4]]:9: warning: binding `x` unused [UnusedBinding]
|
|
// CHECK:STDERR: var x: i32 = 1;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var x: i32 = 1;
|
|
}
|
|
x = 2;
|
|
}
|
|
|
|
// --- param_let_named_not_used.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
// CHECK:STDERR: param_let_named_not_used.carbon:[[@LINE+4]]:6: warning: binding `p` unused [UnusedBinding]
|
|
// CHECK:STDERR: fn F(p: i32) {
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
fn F(p: i32) {
|
|
}
|
|
|
|
// --- param_ref_named_not_used.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
// CHECK:STDERR: param_ref_named_not_used.carbon:[[@LINE+4]]:6: warning: binding `y` unused [UnusedBinding]
|
|
// CHECK:STDERR: fn F(ref y: i32) {
|
|
// CHECK:STDERR: ^~~~~~~~~~
|
|
// CHECK:STDERR:
|
|
fn F(ref y: i32) {
|
|
}
|
|
|
|
// --- fail_read_from_param_unused_ref.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
// CHECK:STDERR: fail_read_from_param_unused_ref.carbon:[[@LINE+3]]:26: error: variable `y` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: fn RefParamUnused(unused ref y: i32) {
|
|
// CHECK:STDERR: ^~~~~~~~~~
|
|
fn RefParamUnused(unused ref y: i32) {
|
|
// CHECK:STDERR: fail_read_from_param_unused_ref.carbon:[[@LINE+4]]:16: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: var _: i32 = y;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
var _: i32 = y;
|
|
}
|
|
|
|
// --- fail_unused_returned_var.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() -> i32 {
|
|
// CHECK:STDERR: fail_unused_returned_var.carbon:[[@LINE+7]]:23: error: variable `x` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: returned var unused x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR: fail_unused_returned_var.carbon:[[@LINE+4]]:23: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: returned var unused x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
returned var unused x: i32 = 0;
|
|
return var;
|
|
}
|
|
|
|
// --- fail_read_from_unused_local_var.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F(x: i32) {
|
|
var _: i32 = x;
|
|
// CHECK:STDERR: fail_read_from_unused_local_var.carbon:[[@LINE+3]]:14: error: variable `y` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: var unused y: i32 = x;
|
|
// CHECK:STDERR: ^~~~~~
|
|
var unused y: i32 = x;
|
|
// CHECK:STDERR: fail_read_from_unused_local_var.carbon:[[@LINE+4]]:23: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: var unused z: i32 = y;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
var unused z: i32 = y;
|
|
}
|
|
|
|
// --- fail_todo_match.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() -> i32 {
|
|
var x: i32 = 3;
|
|
// CHECK:STDERR: fail_todo_match.carbon:[[@LINE+4]]:3: error: semantics TODO: `HandleMatchIntroducer` [SemanticsTodo]
|
|
// CHECK:STDERR: match (f(x)) {
|
|
// CHECK:STDERR: ^~~~~
|
|
// CHECK:STDERR:
|
|
match (f(x)) {
|
|
case unused var (a: i32, b: i32) => { return 0; }
|
|
case (a: i32) if (a < 0) => { return 2; }
|
|
case var unused a: i32 if (a != x) => { return 3; }
|
|
default => { return 4; }
|
|
}
|
|
return 0;
|
|
// TODO: ensure no warning (after match is implemented).
|
|
}
|
|
|
|
// --- fail_unused_decl.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
// CHECK:STDERR: fail_unused_decl.carbon:[[@LINE+4]]:13: error: `unused` modifier without a definition [UnusedModifierWithoutDefinition]
|
|
// CHECK:STDERR: fn F(unused x: i32);
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
fn F(unused x: i32);
|
|
|
|
// --- fail_unused_self_decl.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
class C {
|
|
// CHECK:STDERR: fail_unused_self_decl.carbon:[[@LINE+4]]:15: error: `unused` modifier without a definition [UnusedModifierWithoutDefinition]
|
|
// CHECK:STDERR: fn F(unused self);
|
|
// CHECK:STDERR: ^~~~
|
|
// CHECK:STDERR:
|
|
fn F(unused self);
|
|
}
|
|
|
|
// --- fail_unused_implicit_param_decl.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
// The `unused` modifier is rejected without a definition for any implicit
|
|
// parameter, both a compile-time binding and `self`.
|
|
|
|
// CHECK:STDERR: fail_unused_implicit_param_decl.carbon:[[@LINE+4]]:13: error: `unused` modifier without a definition [UnusedModifierWithoutDefinition]
|
|
// CHECK:STDERR: fn F[unused T: type]();
|
|
// CHECK:STDERR: ^~~~~~~
|
|
// CHECK:STDERR:
|
|
fn F[unused T: type]();
|
|
|
|
class C {
|
|
// CHECK:STDERR: fail_unused_implicit_param_decl.carbon:[[@LINE+8]]:15: error: `self` must be declared in the explicit parameter list [SelfInImplicitParamList]
|
|
// CHECK:STDERR: fn G[unused self: Self]();
|
|
// CHECK:STDERR: ^~~~~~~~~~
|
|
// CHECK:STDERR:
|
|
// CHECK:STDERR: fail_unused_implicit_param_decl.carbon:[[@LINE+4]]:15: error: `unused` modifier without a definition [UnusedModifierWithoutDefinition]
|
|
// CHECK:STDERR: fn G[unused self: Self]();
|
|
// CHECK:STDERR: ^~~~~~~~~~
|
|
// CHECK:STDERR:
|
|
fn G[unused self: Self]();
|
|
}
|
|
|
|
// --- fail_multiple_uses_of_unused.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
// CHECK:STDERR: fail_multiple_uses_of_unused.carbon:[[@LINE+3]]:14: error: variable `x` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: var unused x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
var unused x: i32 = 0;
|
|
// CHECK:STDERR: fail_multiple_uses_of_unused.carbon:[[@LINE+4]]:3: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: x;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
x;
|
|
x;
|
|
}
|
|
|
|
// --- fail_unused_does_not_affect_redeclaration.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F(x: i32);
|
|
// CHECK:STDERR: fail_unused_does_not_affect_redeclaration.carbon:[[@LINE+7]]:13: error: redeclaration differs at parameter 1 [RedeclParamDiffers]
|
|
// CHECK:STDERR: fn F(unused y: i32) {}
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR: fail_unused_does_not_affect_redeclaration.carbon:[[@LINE-4]]:6: note: previous declaration's corresponding parameter here [RedeclParamPrevious]
|
|
// CHECK:STDERR: fn F(x: i32);
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
fn F(unused y: i32) {}
|
|
|
|
// --- unreachable.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F(x: i32) {
|
|
return;
|
|
// Unreachable use suppresses the UnusedBinding warning.
|
|
var y: i32 = x;
|
|
}
|
|
|
|
fn G(unused x: i32) {
|
|
return;
|
|
// Unreachable use is ignored, so no UnusedButUsed error.
|
|
var y: i32 = x;
|
|
}
|
|
|
|
fn H(ref x: i32) {
|
|
return;
|
|
// Unreachable assignment suppresses the UnusedBinding warning.
|
|
x = 0;
|
|
}
|
|
|
|
// --- fail_todo_unused_generic.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F(generic T: type);
|
|
|
|
// CHECK:STDERR: fail_todo_unused_generic.carbon:[[@LINE+4]]:21: error: semantics TODO: `generic redeclaration differs from previous declaration` [SemanticsTodo]
|
|
// CHECK:STDERR: fn F(unused generic T: type) {}
|
|
// CHECK:STDERR: ^~~~~~~
|
|
// CHECK:STDERR:
|
|
fn F(unused generic T: type) {}
|
|
|
|
class C(T: type);
|
|
|
|
// CHECK:STDERR: fail_todo_unused_generic.carbon:[[@LINE+4]]:16: error: semantics TODO: `generic redeclaration differs from previous declaration` [SemanticsTodo]
|
|
// CHECK:STDERR: class C(unused T: type) {}
|
|
// CHECK:STDERR: ^~~~~~~
|
|
// CHECK:STDERR:
|
|
class C(unused T: type) {}
|
|
|
|
// --- fail_unused_let_multiple_uses.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
// CHECK:STDERR: fail_unused_let_multiple_uses.carbon:[[@LINE+3]]:14: error: variable `x` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: let unused x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
let unused x: i32 = 0;
|
|
// CHECK:STDERR: fail_unused_let_multiple_uses.carbon:[[@LINE+8]]:16: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: var y: i32 = x;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
// CHECK:STDERR: fail_unused_let_multiple_uses.carbon:[[@LINE+4]]:7: warning: binding `y` unused [UnusedBinding]
|
|
// CHECK:STDERR: var y: i32 = x;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var y: i32 = x;
|
|
// CHECK:STDERR: fail_unused_let_multiple_uses.carbon:[[@LINE+4]]:7: warning: binding `z` unused [UnusedBinding]
|
|
// CHECK:STDERR: var z: i32 = x;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var z: i32 = x;
|
|
}
|
|
|
|
// --- multiple_unused_bindings.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() {
|
|
// CHECK:STDERR: multiple_unused_bindings.carbon:[[@LINE+4]]:7: warning: binding `x` unused [UnusedBinding]
|
|
// CHECK:STDERR: var x: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var x: i32 = 0;
|
|
// CHECK:STDERR: multiple_unused_bindings.carbon:[[@LINE+4]]:7: warning: binding `y` unused [UnusedBinding]
|
|
// CHECK:STDERR: var y: i32 = 0;
|
|
// CHECK:STDERR: ^~~~~~
|
|
// CHECK:STDERR:
|
|
var y: i32 = 0;
|
|
}
|
|
|
|
// --- fail_unused_tuple.carbon
|
|
library "[[@TEST_NAME]]";
|
|
|
|
fn F() -> i32 {
|
|
// CHECK:STDERR: fail_unused_tuple.carbon:[[@LINE+3]]:14: error: variable `a` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: let unused (a: i32,
|
|
// CHECK:STDERR: ^~~~~~
|
|
let unused (a: i32,
|
|
b: i32) = (1, 2);
|
|
// CHECK:STDERR: fail_unused_tuple.carbon:[[@LINE+7]]:15: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: let i: i32 = a;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
// CHECK:STDERR: fail_unused_tuple.carbon:[[@LINE-5]]:14: error: variable `b` marked `unused` but used [UnusedButUsed]
|
|
// CHECK:STDERR: b: i32) = (1, 2);
|
|
// CHECK:STDERR: ^~~~~~
|
|
let i: i32 = a;
|
|
// CHECK:STDERR: fail_unused_tuple.carbon:[[@LINE+4]]:22: note: usage here [UnusedButUsedHere]
|
|
// CHECK:STDERR: let unused j: i32 = b;
|
|
// CHECK:STDERR: ^
|
|
// CHECK:STDERR:
|
|
let unused j: i32 = b;
|
|
return i;
|
|
}
|