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

Implement unused pattern bindings, continued (#6518)

Browse Source 
Implementation of unused pattern bindings #2022, continued.

Whereas previous PR #6460 took care of parsing, and PR #6479 prepared
the stage by using _ in some test cases, this PR has the the actual
implementation, using a simple dataflow analysis.

---------

Co-authored-by: Burak Emir <bqe@google.com>
Co-authored-by: jonmeow <jperkins@google.com>
This commit is contained in:
Burak Emir
2026-02-19 23:33:36 +00:00
committed by GitHub
co-authored by Burak Emir jonmeow
parent bea24a8bee
commit fdb188ccfd
366 changed files with 8453 additions and 7996 deletions
Download Patch File Download Diff File Expand all files Collapse all files
toolchain/check/testdata/operators/builtin/and.carbon
Vendored
+104 -104
View File
@@ -20,14 +20,14 @@ fn And() -> bool {
}
fn Constant() {
var a: if true and true then bool else () = true;
var b: if true and false then bool else () = ();
var c: if false and true then bool else () = ();
var d: if false and false then bool else () = ();
var unused a: if true and true then bool else () = true;
var unused b: if true and false then bool else () = ();
var unused c: if false and true then bool else () = ();
var unused d: if false and false then bool else () = ();
}
fn PartialConstant(x: bool) {
var a: if false and x then bool else () = ();
var unused a: if false and x then bool else () = ();
}
// CHECK:STDOUT: --- and.carbon
@@ -189,165 +189,165 @@ fn PartialConstant(x: bool) {
// CHECK:STDOUT: %a.var_patt: %pattern_type.831 = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref bool = var %a.var_patt
// CHECK:STDOUT: %true.loc23_47: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %true.loc23_54: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %impl.elem0: %.86d = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op]
// CHECK:STDOUT: %bound_method: <bound method> = bound_method %true.loc23_47, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true.loc23_47) [concrete = constants.%true]
// CHECK:STDOUT: %bound_method: <bound method> = bound_method %true.loc23_54, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true.loc23_54) [concrete = constants.%true]
// CHECK:STDOUT: assign %a.var, %bool.as.Copy.impl.Op.call
// CHECK:STDOUT: br !.loc23_13
// CHECK:STDOUT: br !.loc23_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_13:
// CHECK:STDOUT: %true.loc23_13: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: !.loc23_20:
// CHECK:STDOUT: %true.loc23_20: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %false.loc23: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %true.loc23_13 br !and.rhs.loc23 else br !and.result.loc23(%false.loc23)
// CHECK:STDOUT: if %true.loc23_20 br !and.rhs.loc23 else br !and.result.loc23(%false.loc23)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs.loc23:
// CHECK:STDOUT: %true.loc23_22: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !and.result.loc23(%true.loc23_22)
// CHECK:STDOUT: %true.loc23_29: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !and.result.loc23(%true.loc23_29)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result.loc23:
// CHECK:STDOUT: %.loc23_18: bool = block_arg !and.result.loc23 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_18 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT: %.loc23_25: bool = block_arg !and.result.loc23 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_25 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc23:
// CHECK:STDOUT: %Bool.call.loc23: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc23_32.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_32.2: type = converted %Bool.call.loc23, %.loc23_32.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_32.2)
// CHECK:STDOUT: %.loc23_39.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_39.2: type = converted %Bool.call.loc23, %.loc23_39.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_39.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc23:
// CHECK:STDOUT: %.loc23_43: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_37: type = converted %.loc23_43, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_37)
// CHECK:STDOUT: %.loc23_50: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_44: type = converted %.loc23_50, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_44)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc23:
// CHECK:STDOUT: %.loc23_10: type = block_arg !if.expr.result.loc23 [concrete = bool]
// CHECK:STDOUT: br !.loc23_7
// CHECK:STDOUT: %.loc23_17: type = block_arg !if.expr.result.loc23 [concrete = bool]
// CHECK:STDOUT: br !.loc23_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_7:
// CHECK:STDOUT: !.loc23_14:
// CHECK:STDOUT: %a: ref bool = ref_binding a, %a.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %b.patt: %pattern_type.cb1 = ref_binding_pattern b [concrete]
// CHECK:STDOUT: %b.var_patt: %pattern_type.cb1 = var_pattern %b.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %b.var: ref %empty_tuple.type = var %b.var_patt
// CHECK:STDOUT: %.loc24_49.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_49.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_3: init %empty_tuple.type = converted %.loc24_49.1, %.loc24_49.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_56.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_56.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_3: init %empty_tuple.type = converted %.loc24_56.1, %.loc24_56.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %b.var, %.loc24_3
// CHECK:STDOUT: br !.loc24_13
// CHECK:STDOUT: br !.loc24_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_13:
// CHECK:STDOUT: !.loc24_20:
// CHECK:STDOUT: %true.loc24: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %false.loc24_18: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %true.loc24 br !and.rhs.loc24 else br !and.result.loc24(%false.loc24_18)
// CHECK:STDOUT: %false.loc24_25: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %true.loc24 br !and.rhs.loc24 else br !and.result.loc24(%false.loc24_25)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs.loc24:
// CHECK:STDOUT: %false.loc24_22: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result.loc24(%false.loc24_22)
// CHECK:STDOUT: %false.loc24_29: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result.loc24(%false.loc24_29)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result.loc24:
// CHECK:STDOUT: %.loc24_18: bool = block_arg !and.result.loc24 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc24_18 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT: %.loc24_25: bool = block_arg !and.result.loc24 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc24_25 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc24:
// CHECK:STDOUT: %Bool.call.loc24: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc24_33.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_33.2: type = converted %Bool.call.loc24, %.loc24_33.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_33.2)
// CHECK:STDOUT: %.loc24_40.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_40.2: type = converted %Bool.call.loc24, %.loc24_40.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_40.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc24:
// CHECK:STDOUT: %.loc24_44: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_38: type = converted %.loc24_44, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_38)
// CHECK:STDOUT: %.loc24_51: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_45: type = converted %.loc24_51, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_45)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc24:
// CHECK:STDOUT: %.loc24_10: type = block_arg !if.expr.result.loc24 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc24_7
// CHECK:STDOUT: %.loc24_17: type = block_arg !if.expr.result.loc24 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc24_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_7:
// CHECK:STDOUT: !.loc24_14:
// CHECK:STDOUT: %b: ref %empty_tuple.type = ref_binding b, %b.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %c.patt: %pattern_type.cb1 = ref_binding_pattern c [concrete]
// CHECK:STDOUT: %c.var_patt: %pattern_type.cb1 = var_pattern %c.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %c.var: ref %empty_tuple.type = var %c.var_patt
// CHECK:STDOUT: %.loc25_49.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_49.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_3: init %empty_tuple.type = converted %.loc25_49.1, %.loc25_49.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_56.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_56.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_3: init %empty_tuple.type = converted %.loc25_56.1, %.loc25_56.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %c.var, %.loc25_3
// CHECK:STDOUT: br !.loc25_13
// CHECK:STDOUT: br !.loc25_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc25_13:
// CHECK:STDOUT: %false.loc25_13: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc25_19: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc25_13 br !and.rhs.loc25 else br !and.result.loc25(%false.loc25_19)
// CHECK:STDOUT: !.loc25_20:
// CHECK:STDOUT: %false.loc25_20: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc25_26: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc25_20 br !and.rhs.loc25 else br !and.result.loc25(%false.loc25_26)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs.loc25:
// CHECK:STDOUT: %true.loc25: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !and.result.loc25(%true.loc25)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result.loc25:
// CHECK:STDOUT: %.loc25_19: bool = block_arg !and.result.loc25 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc25_19 br !if.expr.then.loc25 else br !if.expr.else.loc25
// CHECK:STDOUT: %.loc25_26: bool = block_arg !and.result.loc25 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc25_26 br !if.expr.then.loc25 else br !if.expr.else.loc25
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc25:
// CHECK:STDOUT: %Bool.call.loc25: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc25_33.1: type = value_of_initializer %Bool.call.loc25 [concrete = bool]
// CHECK:STDOUT: %.loc25_33.2: type = converted %Bool.call.loc25, %.loc25_33.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_33.2)
// CHECK:STDOUT: %.loc25_40.1: type = value_of_initializer %Bool.call.loc25 [concrete = bool]
// CHECK:STDOUT: %.loc25_40.2: type = converted %Bool.call.loc25, %.loc25_40.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_40.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc25:
// CHECK:STDOUT: %.loc25_44: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_38: type = converted %.loc25_44, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_38)
// CHECK:STDOUT: %.loc25_51: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_45: type = converted %.loc25_51, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_45)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc25:
// CHECK:STDOUT: %.loc25_10: type = block_arg !if.expr.result.loc25 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc25_7
// CHECK:STDOUT: %.loc25_17: type = block_arg !if.expr.result.loc25 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc25_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc25_7:
// CHECK:STDOUT: !.loc25_14:
// CHECK:STDOUT: %c: ref %empty_tuple.type = ref_binding c, %c.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %d.patt: %pattern_type.cb1 = ref_binding_pattern d [concrete]
// CHECK:STDOUT: %d.var_patt: %pattern_type.cb1 = var_pattern %d.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %d.var: ref %empty_tuple.type = var %d.var_patt
// CHECK:STDOUT: %.loc26_50.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_50.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_3: init %empty_tuple.type = converted %.loc26_50.1, %.loc26_50.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_57.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_57.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_3: init %empty_tuple.type = converted %.loc26_57.1, %.loc26_57.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %d.var, %.loc26_3
// CHECK:STDOUT: br !.loc26_13
// CHECK:STDOUT: br !.loc26_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc26_13:
// CHECK:STDOUT: %false.loc26_13: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc26_19: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc26_13 br !and.rhs.loc26 else br !and.result.loc26(%false.loc26_19)
// CHECK:STDOUT: !.loc26_20:
// CHECK:STDOUT: %false.loc26_20: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc26_26: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc26_20 br !and.rhs.loc26 else br !and.result.loc26(%false.loc26_26)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs.loc26:
// CHECK:STDOUT: %false.loc26_23: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result.loc26(%false.loc26_23)
// CHECK:STDOUT: %false.loc26_30: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result.loc26(%false.loc26_30)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result.loc26:
// CHECK:STDOUT: %.loc26_19: bool = block_arg !and.result.loc26 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc26_19 br !if.expr.then.loc26 else br !if.expr.else.loc26
// CHECK:STDOUT: %.loc26_26: bool = block_arg !and.result.loc26 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc26_26 br !if.expr.then.loc26 else br !if.expr.else.loc26
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc26:
// CHECK:STDOUT: %Bool.call.loc26: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc26_34.1: type = value_of_initializer %Bool.call.loc26 [concrete = bool]
// CHECK:STDOUT: %.loc26_34.2: type = converted %Bool.call.loc26, %.loc26_34.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_34.2)
// CHECK:STDOUT: %.loc26_41.1: type = value_of_initializer %Bool.call.loc26 [concrete = bool]
// CHECK:STDOUT: %.loc26_41.2: type = converted %Bool.call.loc26, %.loc26_41.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_41.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc26:
// CHECK:STDOUT: %.loc26_45: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_39: type = converted %.loc26_45, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_39)
// CHECK:STDOUT: %.loc26_52: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_46: type = converted %.loc26_52, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_46)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc26:
// CHECK:STDOUT: %.loc26_10: type = block_arg !if.expr.result.loc26 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc26_7
// CHECK:STDOUT: %.loc26_17: type = block_arg !if.expr.result.loc26 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc26_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc26_7:
// CHECK:STDOUT: !.loc26_14:
// CHECK:STDOUT: %d: ref %empty_tuple.type = ref_binding d, %d.var
// CHECK:STDOUT: %DestroyOp.bound.loc26: <bound method> = bound_method %d.var, constants.%DestroyOp.b0ebf8.1
// CHECK:STDOUT: %DestroyOp.call.loc26: init %empty_tuple.type = call %DestroyOp.bound.loc26(%d.var)
@@ -371,41 +371,41 @@ fn PartialConstant(x: bool) {
// CHECK:STDOUT: %a.var_patt: %pattern_type.cb1 = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref %empty_tuple.type = var %a.var_patt
// CHECK:STDOUT: %.loc30_46.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_46.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_3: init %empty_tuple.type = converted %.loc30_46.1, %.loc30_46.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_53.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_53.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_3: init %empty_tuple.type = converted %.loc30_53.1, %.loc30_53.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %a.var, %.loc30_3
// CHECK:STDOUT: br !.loc30_13
// CHECK:STDOUT: br !.loc30_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc30_13:
// CHECK:STDOUT: %false.loc30_13: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc30_19: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc30_13 br !and.rhs else br !and.result(%false.loc30_19)
// CHECK:STDOUT: !.loc30_20:
// CHECK:STDOUT: %false.loc30_20: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %false.loc30_26: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %false.loc30_20 br !and.rhs else br !and.result(%false.loc30_26)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs:
// CHECK:STDOUT: %x.ref: bool = name_ref x, %x
// CHECK:STDOUT: br !and.result(%x.ref)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result:
// CHECK:STDOUT: %.loc30_19: bool = block_arg !and.result [concrete = constants.%false]
// CHECK:STDOUT: if %.loc30_19 br !if.expr.then else br !if.expr.else
// CHECK:STDOUT: %.loc30_26: bool = block_arg !and.result [concrete = constants.%false]
// CHECK:STDOUT: if %.loc30_26 br !if.expr.then else br !if.expr.else
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then:
// CHECK:STDOUT: %Bool.call.loc30: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc30_30.1: type = value_of_initializer %Bool.call.loc30 [concrete = bool]
// CHECK:STDOUT: %.loc30_30.2: type = converted %Bool.call.loc30, %.loc30_30.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result(%.loc30_30.2)
// CHECK:STDOUT: %.loc30_37.1: type = value_of_initializer %Bool.call.loc30 [concrete = bool]
// CHECK:STDOUT: %.loc30_37.2: type = converted %Bool.call.loc30, %.loc30_37.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result(%.loc30_37.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else:
// CHECK:STDOUT: %.loc30_41: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_35: type = converted %.loc30_41, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result(%.loc30_35)
// CHECK:STDOUT: %.loc30_48: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_42: type = converted %.loc30_48, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result(%.loc30_42)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result:
// CHECK:STDOUT: %.loc30_10: type = block_arg !if.expr.result [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc30_7
// CHECK:STDOUT: %.loc30_17: type = block_arg !if.expr.result [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc30_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc30_7:
// CHECK:STDOUT: !.loc30_14:
// CHECK:STDOUT: %a: ref %empty_tuple.type = ref_binding a, %a.var
// CHECK:STDOUT: %DestroyOp.bound: <bound method> = bound_method %a.var, constants.%DestroyOp.b0ebf8.1
// CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var)
toolchain/check/testdata/operators/builtin/bit_and.carbon
Vendored
+10 -10
View File
@@ -16,8 +16,8 @@ library "[[@TEST_NAME]]";
interface I {}
interface J {}
fn F1[T:! I & J](t: T) {}
fn F2[T:! I & I](t: T) {}
fn F1[T:! I & J](unused t: T) {}
fn F2[T:! I & I](unused t: T) {}
// --- fail_bit_and_non_facet_types.carbon
library "[[@TEST_NAME]]";
@@ -27,31 +27,31 @@ class J {}
class K {}
// CHECK:STDERR: fail_bit_and_non_facet_types.carbon:[[@LINE+4]]:11: error: non-facet type `J` combined with `&` operator [FacetTypeRequiredForTypeAndOperator]
// CHECK:STDERR: fn F1[T:! I & J](t: T) {}
// CHECK:STDERR: fn F1[T:! I & J](unused t: T) {}
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
fn F1[T:! I & J](t: T) {}
fn F1[T:! I & J](unused t: T) {}
// CHECK:STDERR: fail_bit_and_non_facet_types.carbon:[[@LINE+4]]:11: error: non-facet type `J` combined with `&` operator [FacetTypeRequiredForTypeAndOperator]
// CHECK:STDERR: fn F2[T:! J & I](t: T) {}
// CHECK:STDERR: fn F2[T:! J & I](unused t: T) {}
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
fn F2[T:! J & I](t: T) {}
fn F2[T:! J & I](unused t: T) {}
// CHECK:STDERR: fail_bit_and_non_facet_types.carbon:[[@LINE+8]]:11: error: non-facet type `J` combined with `&` operator [FacetTypeRequiredForTypeAndOperator]
// CHECK:STDERR: fn F3[T:! J & K](t: T) {}
// CHECK:STDERR: fn F3[T:! J & K](unused t: T) {}
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
// CHECK:STDERR: fail_bit_and_non_facet_types.carbon:[[@LINE+4]]:11: error: non-facet type `K` combined with `&` operator [FacetTypeRequiredForTypeAndOperator]
// CHECK:STDERR: fn F3[T:! J & K](t: T) {}
// CHECK:STDERR: fn F3[T:! J & K](unused t: T) {}
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
fn F3[T:! J & K](t: T) {}
fn F3[T:! J & K](unused t: T) {}
// --- bit_and_values_with_impl.carbon
library "[[@TEST_NAME]]";
class J { adapt {}; }
impl J as Core.BitAndWith(J) where .Result = J {
fn Op[self: Self](other: Self) -> Self { return {} as J; }
fn Op[unused self: Self](unused other: Self) -> Self { return {} as J; }
}
fn F() {
toolchain/check/testdata/operators/builtin/fail_and_or_partial_constant.carbon
Vendored
+79 -79
View File
@@ -17,16 +17,16 @@
package FailNonConstantResult;
fn PartialConstant(x: bool) {
// CHECK:STDERR: fail_non_constant_result.carbon:[[@LINE+4]]:10: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var a: if true and x then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR: fail_non_constant_result.carbon:[[@LINE+4]]:17: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var unused a: if true and x then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR:
var a: if true and x then bool else ();
// CHECK:STDERR: fail_non_constant_result.carbon:[[@LINE+4]]:10: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var b: if false or x then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
var unused a: if true and x then bool else ();
// CHECK:STDERR: fail_non_constant_result.carbon:[[@LINE+4]]:17: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var unused b: if false or x then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR:
var b: if false or x then bool else ();
var unused b: if false or x then bool else ();
}
// --- fail_despite_known_result.carbon
@@ -36,16 +36,16 @@ package FailDespiteKnownResult;
fn KnownValueButNonConstantCondition(x: bool) {
// We choose not to give these cases constant values, even though we could,
// because they notionally involve evaluating a non-constant condition.
// CHECK:STDERR: fail_despite_known_result.carbon:[[@LINE+4]]:10: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var c: if x and false then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR: fail_despite_known_result.carbon:[[@LINE+4]]:17: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var unused c: if x and false then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR:
var c: if x and false then bool else ();
// CHECK:STDERR: fail_despite_known_result.carbon:[[@LINE+4]]:10: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var d: if x or true then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
var unused c: if x and false then bool else ();
// CHECK:STDERR: fail_despite_known_result.carbon:[[@LINE+4]]:17: error: cannot evaluate type expression [TypeExprEvaluationFailure]
// CHECK:STDERR: var unused d: if x or true then bool else ();
// CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CHECK:STDERR:
var d: if x or true then bool else ();
var unused d: if x or true then bool else ();
}
// CHECK:STDOUT: --- fail_non_constant_result.carbon
@@ -101,9 +101,9 @@ fn KnownValueButNonConstantCondition(x: bool) {
// CHECK:STDOUT: %a.var_patt: <error> = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref <error> = var %a.var_patt [concrete = <error>]
// CHECK:STDOUT: br !.loc9_13
// CHECK:STDOUT: br !.loc9_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc9_13:
// CHECK:STDOUT: !.loc9_20:
// CHECK:STDOUT: %true.loc9: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %false.loc9: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %true.loc9 br !and.rhs else br !and.result(%false.loc9)
@@ -113,63 +113,63 @@ fn KnownValueButNonConstantCondition(x: bool) {
// CHECK:STDOUT: br !and.result(%x.ref.loc9)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result:
// CHECK:STDOUT: %.loc9_18: bool = block_arg !and.result
// CHECK:STDOUT: if %.loc9_18 br !if.expr.then.loc9 else br !if.expr.else.loc9
// CHECK:STDOUT: %.loc9_25: bool = block_arg !and.result
// CHECK:STDOUT: if %.loc9_25 br !if.expr.then.loc9 else br !if.expr.else.loc9
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc9:
// CHECK:STDOUT: %Bool.call.loc9: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc9_29.1: type = value_of_initializer %Bool.call.loc9 [concrete = bool]
// CHECK:STDOUT: %.loc9_29.2: type = converted %Bool.call.loc9, %.loc9_29.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc9(%.loc9_29.2)
// CHECK:STDOUT: %.loc9_36.1: type = value_of_initializer %Bool.call.loc9 [concrete = bool]
// CHECK:STDOUT: %.loc9_36.2: type = converted %Bool.call.loc9, %.loc9_36.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc9(%.loc9_36.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc9:
// CHECK:STDOUT: %.loc9_40: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_34: type = converted %.loc9_40, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc9(%.loc9_34)
// CHECK:STDOUT: %.loc9_47: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_41: type = converted %.loc9_47, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc9(%.loc9_41)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc9:
// CHECK:STDOUT: %.loc9_10: type = block_arg !if.expr.result.loc9
// CHECK:STDOUT: br !.loc9_7
// CHECK:STDOUT: %.loc9_17: type = block_arg !if.expr.result.loc9
// CHECK:STDOUT: br !.loc9_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc9_7:
// CHECK:STDOUT: !.loc9_14:
// CHECK:STDOUT: %a: ref <error> = ref_binding a, <error> [concrete = <error>]
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %b.patt: <error> = ref_binding_pattern b [concrete]
// CHECK:STDOUT: %b.var_patt: <error> = var_pattern %b.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %b.var: ref <error> = var %b.var_patt [concrete = <error>]
// CHECK:STDOUT: br !.loc14_13
// CHECK:STDOUT: br !.loc14_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc14_13:
// CHECK:STDOUT: !.loc14_20:
// CHECK:STDOUT: %false.loc14: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %.loc14_19.1: bool = not %false.loc14 [concrete = constants.%true]
// CHECK:STDOUT: %.loc14_26.1: bool = not %false.loc14 [concrete = constants.%true]
// CHECK:STDOUT: %true.loc14: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc14_19.1 br !or.rhs else br !or.result(%true.loc14)
// CHECK:STDOUT: if %.loc14_26.1 br !or.rhs else br !or.result(%true.loc14)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs:
// CHECK:STDOUT: %x.ref.loc14: bool = name_ref x, %x
// CHECK:STDOUT: br !or.result(%x.ref.loc14)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result:
// CHECK:STDOUT: %.loc14_19.2: bool = block_arg !or.result
// CHECK:STDOUT: if %.loc14_19.2 br !if.expr.then.loc14 else br !if.expr.else.loc14
// CHECK:STDOUT: %.loc14_26.2: bool = block_arg !or.result
// CHECK:STDOUT: if %.loc14_26.2 br !if.expr.then.loc14 else br !if.expr.else.loc14
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc14:
// CHECK:STDOUT: %Bool.call.loc14: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc14_29.1: type = value_of_initializer %Bool.call.loc14 [concrete = bool]
// CHECK:STDOUT: %.loc14_29.2: type = converted %Bool.call.loc14, %.loc14_29.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc14(%.loc14_29.2)
// CHECK:STDOUT: %.loc14_36.1: type = value_of_initializer %Bool.call.loc14 [concrete = bool]
// CHECK:STDOUT: %.loc14_36.2: type = converted %Bool.call.loc14, %.loc14_36.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc14(%.loc14_36.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc14:
// CHECK:STDOUT: %.loc14_40: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc14_34: type = converted %.loc14_40, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc14(%.loc14_34)
// CHECK:STDOUT: %.loc14_47: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc14_41: type = converted %.loc14_47, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc14(%.loc14_41)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc14:
// CHECK:STDOUT: %.loc14_10: type = block_arg !if.expr.result.loc14
// CHECK:STDOUT: br !.loc14_7
// CHECK:STDOUT: %.loc14_17: type = block_arg !if.expr.result.loc14
// CHECK:STDOUT: br !.loc14_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc14_7:
// CHECK:STDOUT: !.loc14_14:
// CHECK:STDOUT: %b: ref <error> = ref_binding b, <error> [concrete = <error>]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
@@ -227,75 +227,75 @@ fn KnownValueButNonConstantCondition(x: bool) {
// CHECK:STDOUT: %c.var_patt: <error> = var_pattern %c.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %c.var: ref <error> = var %c.var_patt [concrete = <error>]
// CHECK:STDOUT: br !.loc11_13
// CHECK:STDOUT: br !.loc11_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc11_13:
// CHECK:STDOUT: !.loc11_20:
// CHECK:STDOUT: %x.ref.loc11: bool = name_ref x, %x
// CHECK:STDOUT: %false.loc11_15: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %x.ref.loc11 br !and.rhs else br !and.result(%false.loc11_15)
// CHECK:STDOUT: %false.loc11_22: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: if %x.ref.loc11 br !and.rhs else br !and.result(%false.loc11_22)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs:
// CHECK:STDOUT: %false.loc11_19: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result(%false.loc11_19)
// CHECK:STDOUT: %false.loc11_26: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !and.result(%false.loc11_26)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result:
// CHECK:STDOUT: %.loc11_15: bool = block_arg !and.result
// CHECK:STDOUT: if %.loc11_15 br !if.expr.then.loc11 else br !if.expr.else.loc11
// CHECK:STDOUT: %.loc11_22: bool = block_arg !and.result
// CHECK:STDOUT: if %.loc11_22 br !if.expr.then.loc11 else br !if.expr.else.loc11
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc11:
// CHECK:STDOUT: %Bool.call.loc11: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc11_30.1: type = value_of_initializer %Bool.call.loc11 [concrete = bool]
// CHECK:STDOUT: %.loc11_30.2: type = converted %Bool.call.loc11, %.loc11_30.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc11(%.loc11_30.2)
// CHECK:STDOUT: %.loc11_37.1: type = value_of_initializer %Bool.call.loc11 [concrete = bool]
// CHECK:STDOUT: %.loc11_37.2: type = converted %Bool.call.loc11, %.loc11_37.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc11(%.loc11_37.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc11:
// CHECK:STDOUT: %.loc11_41: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc11_35: type = converted %.loc11_41, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc11(%.loc11_35)
// CHECK:STDOUT: %.loc11_48: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc11_42: type = converted %.loc11_48, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc11(%.loc11_42)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc11:
// CHECK:STDOUT: %.loc11_10: type = block_arg !if.expr.result.loc11
// CHECK:STDOUT: br !.loc11_7
// CHECK:STDOUT: %.loc11_17: type = block_arg !if.expr.result.loc11
// CHECK:STDOUT: br !.loc11_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc11_7:
// CHECK:STDOUT: !.loc11_14:
// CHECK:STDOUT: %c: ref <error> = ref_binding c, <error> [concrete = <error>]
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %d.patt: <error> = ref_binding_pattern d [concrete]
// CHECK:STDOUT: %d.var_patt: <error> = var_pattern %d.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %d.var: ref <error> = var %d.var_patt [concrete = <error>]
// CHECK:STDOUT: br !.loc16_13
// CHECK:STDOUT: br !.loc16_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc16_13:
// CHECK:STDOUT: !.loc16_20:
// CHECK:STDOUT: %x.ref.loc16: bool = name_ref x, %x
// CHECK:STDOUT: %.loc16_15.1: bool = not %x.ref.loc16
// CHECK:STDOUT: %true.loc16_15: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc16_15.1 br !or.rhs else br !or.result(%true.loc16_15)
// CHECK:STDOUT: %.loc16_22.1: bool = not %x.ref.loc16
// CHECK:STDOUT: %true.loc16_22: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc16_22.1 br !or.rhs else br !or.result(%true.loc16_22)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs:
// CHECK:STDOUT: %true.loc16_18: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result(%true.loc16_18)
// CHECK:STDOUT: %true.loc16_25: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result(%true.loc16_25)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result:
// CHECK:STDOUT: %.loc16_15.2: bool = block_arg !or.result
// CHECK:STDOUT: if %.loc16_15.2 br !if.expr.then.loc16 else br !if.expr.else.loc16
// CHECK:STDOUT: %.loc16_22.2: bool = block_arg !or.result
// CHECK:STDOUT: if %.loc16_22.2 br !if.expr.then.loc16 else br !if.expr.else.loc16
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc16:
// CHECK:STDOUT: %Bool.call.loc16: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc16_28.1: type = value_of_initializer %Bool.call.loc16 [concrete = bool]
// CHECK:STDOUT: %.loc16_28.2: type = converted %Bool.call.loc16, %.loc16_28.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc16(%.loc16_28.2)
// CHECK:STDOUT: %.loc16_35.1: type = value_of_initializer %Bool.call.loc16 [concrete = bool]
// CHECK:STDOUT: %.loc16_35.2: type = converted %Bool.call.loc16, %.loc16_35.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc16(%.loc16_35.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc16:
// CHECK:STDOUT: %.loc16_39: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc16_33: type = converted %.loc16_39, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc16(%.loc16_33)
// CHECK:STDOUT: %.loc16_46: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc16_40: type = converted %.loc16_46, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc16(%.loc16_40)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc16:
// CHECK:STDOUT: %.loc16_10: type = block_arg !if.expr.result.loc16
// CHECK:STDOUT: br !.loc16_7
// CHECK:STDOUT: %.loc16_17: type = block_arg !if.expr.result.loc16
// CHECK:STDOUT: br !.loc16_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc16_7:
// CHECK:STDOUT: !.loc16_14:
// CHECK:STDOUT: %d: ref <error> = ref_binding d, <error> [concrete = <error>]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
toolchain/check/testdata/operators/builtin/fail_type_mismatch.carbon
Vendored
+12 -12
View File
@@ -13,14 +13,14 @@
// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/operators/builtin/fail_type_mismatch.carbon
fn Main() {
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+7]]:17: error: cannot implicitly convert expression of type `Core.IntLiteral` to `bool` [ConversionFailure]
// CHECK:STDERR: var x: bool = not 12;
// CHECK:STDERR: ^~~~~~
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+4]]:17: note: type `Core.IntLiteral` does not implement interface `Core.ImplicitAs(bool)` [MissingImplInMemberAccessNote]
// CHECK:STDERR: var x: bool = not 12;
// CHECK:STDERR: ^~~~~~
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+7]]:24: error: cannot implicitly convert expression of type `Core.IntLiteral` to `bool` [ConversionFailure]
// CHECK:STDERR: var unused x: bool = not 12;
// CHECK:STDERR: ^~~~~~
// CHECK:STDERR: fail_type_mismatch.carbon:[[@LINE+4]]:24: note: type `Core.IntLiteral` does not implement interface `Core.ImplicitAs(bool)` [MissingImplInMemberAccessNote]
// CHECK:STDERR: var unused x: bool = not 12;
// CHECK:STDERR: ^~~~~~
// CHECK:STDERR:
var x: bool = not 12;
var unused x: bool = not 12;
}
// CHECK:STDOUT: --- fail_type_mismatch.carbon
@@ -70,13 +70,13 @@ fn Main() {
// CHECK:STDOUT: }
// CHECK:STDOUT: %x.var: ref bool = var %x.var_patt
// CHECK:STDOUT: %int_12: Core.IntLiteral = int_value 12 [concrete = constants.%int_12]
// CHECK:STDOUT: %.loc23_17.1: bool = converted %int_12, <error> [concrete = <error>]
// CHECK:STDOUT: %.loc23_17.2: <error> = not <error> [concrete = <error>]
// CHECK:STDOUT: %.loc23_24.1: bool = converted %int_12, <error> [concrete = <error>]
// CHECK:STDOUT: %.loc23_24.2: <error> = not <error> [concrete = <error>]
// CHECK:STDOUT: assign %x.var, <error>
// CHECK:STDOUT: %.loc23_10.1: type = splice_block %.loc23_10.3 [concrete = bool] {
// CHECK:STDOUT: %.loc23_17.1: type = splice_block %.loc23_17.3 [concrete = bool] {
// CHECK:STDOUT: %Bool.call: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc23_10.2: type = value_of_initializer %Bool.call [concrete = bool]
// CHECK:STDOUT: %.loc23_10.3: type = converted %Bool.call, %.loc23_10.2 [concrete = bool]
// CHECK:STDOUT: %.loc23_17.2: type = value_of_initializer %Bool.call [concrete = bool]
// CHECK:STDOUT: %.loc23_17.3: type = converted %Bool.call, %.loc23_17.2 [concrete = bool]
// CHECK:STDOUT: }
// CHECK:STDOUT: %x: ref bool = ref_binding x, %x.var
// CHECK:STDOUT: %DestroyOp.bound: <bound method> = bound_method %x.var, constants.%DestroyOp
toolchain/check/testdata/operators/builtin/or.carbon
Vendored
+109 -109
View File
@@ -20,14 +20,14 @@ fn Or() -> bool {
}
fn Constant() {
var a: if true or true then bool else () = true;
var b: if true or false then bool else () = true;
var c: if false or true then bool else () = true;
var d: if false or false then bool else () = ();
var unused a: if true or true then bool else () = true;
var unused b: if true or false then bool else () = true;
var unused c: if false or true then bool else () = true;
var unused d: if false or false then bool else () = ();
}
fn PartialConstant(x: bool) {
var a: if true or x then bool else () = true;
var unused a: if true or x then bool else () = true;
}
// CHECK:STDOUT: --- or.carbon
@@ -190,171 +190,171 @@ fn PartialConstant(x: bool) {
// CHECK:STDOUT: %a.var_patt: %pattern_type.831 = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref bool = var %a.var_patt
// CHECK:STDOUT: %true.loc23_46: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %true.loc23_53: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %impl.elem0.loc23: %.86d = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op]
// CHECK:STDOUT: %bound_method.loc23: <bound method> = bound_method %true.loc23_46, %impl.elem0.loc23 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc23: init bool = call %bound_method.loc23(%true.loc23_46) [concrete = constants.%true]
// CHECK:STDOUT: %bound_method.loc23: <bound method> = bound_method %true.loc23_53, %impl.elem0.loc23 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc23: init bool = call %bound_method.loc23(%true.loc23_53) [concrete = constants.%true]
// CHECK:STDOUT: assign %a.var, %bool.as.Copy.impl.Op.call.loc23
// CHECK:STDOUT: br !.loc23_13
// CHECK:STDOUT: br !.loc23_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_13:
// CHECK:STDOUT: %true.loc23_13: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc23_18.1: bool = not %true.loc23_13 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc23_18: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_18.1 br !or.rhs.loc23 else br !or.result.loc23(%true.loc23_18)
// CHECK:STDOUT: !.loc23_20:
// CHECK:STDOUT: %true.loc23_20: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc23_25.1: bool = not %true.loc23_20 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc23_25: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_25.1 br !or.rhs.loc23 else br !or.result.loc23(%true.loc23_25)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs.loc23:
// CHECK:STDOUT: %true.loc23_21: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result.loc23(%true.loc23_21)
// CHECK:STDOUT: %true.loc23_28: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result.loc23(%true.loc23_28)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result.loc23:
// CHECK:STDOUT: %.loc23_18.2: bool = block_arg !or.result.loc23 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_18.2 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT: %.loc23_25.2: bool = block_arg !or.result.loc23 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc23_25.2 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc23:
// CHECK:STDOUT: %Bool.call.loc23: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc23_31.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_31.2: type = converted %Bool.call.loc23, %.loc23_31.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_31.2)
// CHECK:STDOUT: %.loc23_38.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_38.2: type = converted %Bool.call.loc23, %.loc23_38.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_38.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc23:
// CHECK:STDOUT: %.loc23_42: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_36: type = converted %.loc23_42, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_36)
// CHECK:STDOUT: %.loc23_49: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_43: type = converted %.loc23_49, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_43)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc23:
// CHECK:STDOUT: %.loc23_10: type = block_arg !if.expr.result.loc23 [concrete = bool]
// CHECK:STDOUT: br !.loc23_7
// CHECK:STDOUT: %.loc23_17: type = block_arg !if.expr.result.loc23 [concrete = bool]
// CHECK:STDOUT: br !.loc23_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_7:
// CHECK:STDOUT: !.loc23_14:
// CHECK:STDOUT: %a: ref bool = ref_binding a, %a.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %b.patt: %pattern_type.831 = ref_binding_pattern b [concrete]
// CHECK:STDOUT: %b.var_patt: %pattern_type.831 = var_pattern %b.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %b.var: ref bool = var %b.var_patt
// CHECK:STDOUT: %true.loc24_47: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %true.loc24_54: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %impl.elem0.loc24: %.86d = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op]
// CHECK:STDOUT: %bound_method.loc24: <bound method> = bound_method %true.loc24_47, %impl.elem0.loc24 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc24: init bool = call %bound_method.loc24(%true.loc24_47) [concrete = constants.%true]
// CHECK:STDOUT: %bound_method.loc24: <bound method> = bound_method %true.loc24_54, %impl.elem0.loc24 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc24: init bool = call %bound_method.loc24(%true.loc24_54) [concrete = constants.%true]
// CHECK:STDOUT: assign %b.var, %bool.as.Copy.impl.Op.call.loc24
// CHECK:STDOUT: br !.loc24_13
// CHECK:STDOUT: br !.loc24_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_13:
// CHECK:STDOUT: %true.loc24_13: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc24_18.1: bool = not %true.loc24_13 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc24_18: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_18.1 br !or.rhs.loc24 else br !or.result.loc24(%true.loc24_18)
// CHECK:STDOUT: !.loc24_20:
// CHECK:STDOUT: %true.loc24_20: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc24_25.1: bool = not %true.loc24_20 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc24_25: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_25.1 br !or.rhs.loc24 else br !or.result.loc24(%true.loc24_25)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs.loc24:
// CHECK:STDOUT: %false.loc24: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !or.result.loc24(%false.loc24)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result.loc24:
// CHECK:STDOUT: %.loc24_18.2: bool = block_arg !or.result.loc24 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_18.2 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT: %.loc24_25.2: bool = block_arg !or.result.loc24 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_25.2 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc24:
// CHECK:STDOUT: %Bool.call.loc24: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc24_32.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_32.2: type = converted %Bool.call.loc24, %.loc24_32.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_32.2)
// CHECK:STDOUT: %.loc24_39.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_39.2: type = converted %Bool.call.loc24, %.loc24_39.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_39.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc24:
// CHECK:STDOUT: %.loc24_43: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_37: type = converted %.loc24_43, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_37)
// CHECK:STDOUT: %.loc24_50: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_44: type = converted %.loc24_50, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_44)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc24:
// CHECK:STDOUT: %.loc24_10: type = block_arg !if.expr.result.loc24 [concrete = bool]
// CHECK:STDOUT: br !.loc24_7
// CHECK:STDOUT: %.loc24_17: type = block_arg !if.expr.result.loc24 [concrete = bool]
// CHECK:STDOUT: br !.loc24_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_7:
// CHECK:STDOUT: !.loc24_14:
// CHECK:STDOUT: %b: ref bool = ref_binding b, %b.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %c.patt: %pattern_type.831 = ref_binding_pattern c [concrete]
// CHECK:STDOUT: %c.var_patt: %pattern_type.831 = var_pattern %c.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %c.var: ref bool = var %c.var_patt
// CHECK:STDOUT: %true.loc25_47: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %true.loc25_54: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %impl.elem0.loc25: %.86d = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op]
// CHECK:STDOUT: %bound_method.loc25: <bound method> = bound_method %true.loc25_47, %impl.elem0.loc25 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc25: init bool = call %bound_method.loc25(%true.loc25_47) [concrete = constants.%true]
// CHECK:STDOUT: %bound_method.loc25: <bound method> = bound_method %true.loc25_54, %impl.elem0.loc25 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call.loc25: init bool = call %bound_method.loc25(%true.loc25_54) [concrete = constants.%true]
// CHECK:STDOUT: assign %c.var, %bool.as.Copy.impl.Op.call.loc25
// CHECK:STDOUT: br !.loc25_13
// CHECK:STDOUT: br !.loc25_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc25_13:
// CHECK:STDOUT: !.loc25_20:
// CHECK:STDOUT: %false.loc25: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %.loc25_19.1: bool = not %false.loc25 [concrete = constants.%true]
// CHECK:STDOUT: %true.loc25_19: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc25_19.1 br !or.rhs.loc25 else br !or.result.loc25(%true.loc25_19)
// CHECK:STDOUT: %.loc25_26.1: bool = not %false.loc25 [concrete = constants.%true]
// CHECK:STDOUT: %true.loc25_26: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc25_26.1 br !or.rhs.loc25 else br !or.result.loc25(%true.loc25_26)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs.loc25:
// CHECK:STDOUT: %true.loc25_22: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result.loc25(%true.loc25_22)
// CHECK:STDOUT: %true.loc25_29: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: br !or.result.loc25(%true.loc25_29)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result.loc25:
// CHECK:STDOUT: %.loc25_19.2: bool = block_arg !or.result.loc25 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc25_19.2 br !if.expr.then.loc25 else br !if.expr.else.loc25
// CHECK:STDOUT: %.loc25_26.2: bool = block_arg !or.result.loc25 [concrete = constants.%true]
// CHECK:STDOUT: if %.loc25_26.2 br !if.expr.then.loc25 else br !if.expr.else.loc25
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc25:
// CHECK:STDOUT: %Bool.call.loc25: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc25_32.1: type = value_of_initializer %Bool.call.loc25 [concrete = bool]
// CHECK:STDOUT: %.loc25_32.2: type = converted %Bool.call.loc25, %.loc25_32.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_32.2)
// CHECK:STDOUT: %.loc25_39.1: type = value_of_initializer %Bool.call.loc25 [concrete = bool]
// CHECK:STDOUT: %.loc25_39.2: type = converted %Bool.call.loc25, %.loc25_39.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_39.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc25:
// CHECK:STDOUT: %.loc25_43: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_37: type = converted %.loc25_43, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_37)
// CHECK:STDOUT: %.loc25_50: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc25_44: type = converted %.loc25_50, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc25(%.loc25_44)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc25:
// CHECK:STDOUT: %.loc25_10: type = block_arg !if.expr.result.loc25 [concrete = bool]
// CHECK:STDOUT: br !.loc25_7
// CHECK:STDOUT: %.loc25_17: type = block_arg !if.expr.result.loc25 [concrete = bool]
// CHECK:STDOUT: br !.loc25_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc25_7:
// CHECK:STDOUT: !.loc25_14:
// CHECK:STDOUT: %c: ref bool = ref_binding c, %c.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %d.patt: %pattern_type.cb1 = ref_binding_pattern d [concrete]
// CHECK:STDOUT: %d.var_patt: %pattern_type.cb1 = var_pattern %d.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %d.var: ref %empty_tuple.type = var %d.var_patt
// CHECK:STDOUT: %.loc26_49.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_49.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_3: init %empty_tuple.type = converted %.loc26_49.1, %.loc26_49.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_56.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_56.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_3: init %empty_tuple.type = converted %.loc26_56.1, %.loc26_56.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %d.var, %.loc26_3
// CHECK:STDOUT: br !.loc26_13
// CHECK:STDOUT: br !.loc26_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc26_13:
// CHECK:STDOUT: %false.loc26_13: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %.loc26_19.1: bool = not %false.loc26_13 [concrete = constants.%true]
// CHECK:STDOUT: !.loc26_20:
// CHECK:STDOUT: %false.loc26_20: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %.loc26_26.1: bool = not %false.loc26_20 [concrete = constants.%true]
// CHECK:STDOUT: %true.loc26: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc26_19.1 br !or.rhs.loc26 else br !or.result.loc26(%true.loc26)
// CHECK:STDOUT: if %.loc26_26.1 br !or.rhs.loc26 else br !or.result.loc26(%true.loc26)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs.loc26:
// CHECK:STDOUT: %false.loc26_22: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !or.result.loc26(%false.loc26_22)
// CHECK:STDOUT: %false.loc26_29: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: br !or.result.loc26(%false.loc26_29)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result.loc26:
// CHECK:STDOUT: %.loc26_19.2: bool = block_arg !or.result.loc26 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc26_19.2 br !if.expr.then.loc26 else br !if.expr.else.loc26
// CHECK:STDOUT: %.loc26_26.2: bool = block_arg !or.result.loc26 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc26_26.2 br !if.expr.then.loc26 else br !if.expr.else.loc26
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc26:
// CHECK:STDOUT: %Bool.call.loc26: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc26_33.1: type = value_of_initializer %Bool.call.loc26 [concrete = bool]
// CHECK:STDOUT: %.loc26_33.2: type = converted %Bool.call.loc26, %.loc26_33.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_33.2)
// CHECK:STDOUT: %.loc26_40.1: type = value_of_initializer %Bool.call.loc26 [concrete = bool]
// CHECK:STDOUT: %.loc26_40.2: type = converted %Bool.call.loc26, %.loc26_40.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_40.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc26:
// CHECK:STDOUT: %.loc26_44: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_38: type = converted %.loc26_44, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_38)
// CHECK:STDOUT: %.loc26_51: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc26_45: type = converted %.loc26_51, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc26(%.loc26_45)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc26:
// CHECK:STDOUT: %.loc26_10: type = block_arg !if.expr.result.loc26 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc26_7
// CHECK:STDOUT: %.loc26_17: type = block_arg !if.expr.result.loc26 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc26_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc26_7:
// CHECK:STDOUT: !.loc26_14:
// CHECK:STDOUT: %d: ref %empty_tuple.type = ref_binding d, %d.var
// CHECK:STDOUT: %DestroyOp.bound.loc26: <bound method> = bound_method %d.var, constants.%DestroyOp.b0ebf8.1
// CHECK:STDOUT: %DestroyOp.call.loc26: init %empty_tuple.type = call %DestroyOp.bound.loc26(%d.var)
@@ -378,43 +378,43 @@ fn PartialConstant(x: bool) {
// CHECK:STDOUT: %a.var_patt: %pattern_type.831 = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref bool = var %a.var_patt
// CHECK:STDOUT: %true.loc30_43: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %true.loc30_50: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %impl.elem0: %.86d = impl_witness_access constants.%Copy.impl_witness.348, element0 [concrete = constants.%bool.as.Copy.impl.Op]
// CHECK:STDOUT: %bound_method: <bound method> = bound_method %true.loc30_43, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true.loc30_43) [concrete = constants.%true]
// CHECK:STDOUT: %bound_method: <bound method> = bound_method %true.loc30_50, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true.loc30_50) [concrete = constants.%true]
// CHECK:STDOUT: assign %a.var, %bool.as.Copy.impl.Op.call
// CHECK:STDOUT: br !.loc30_13
// CHECK:STDOUT: br !.loc30_20
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc30_13:
// CHECK:STDOUT: %true.loc30_13: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc30_18.1: bool = not %true.loc30_13 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc30_18: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc30_18.1 br !or.rhs else br !or.result(%true.loc30_18)
// CHECK:STDOUT: !.loc30_20:
// CHECK:STDOUT: %true.loc30_20: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc30_25.1: bool = not %true.loc30_20 [concrete = constants.%false]
// CHECK:STDOUT: %true.loc30_25: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: if %.loc30_25.1 br !or.rhs else br !or.result(%true.loc30_25)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.rhs:
// CHECK:STDOUT: %x.ref: bool = name_ref x, %x
// CHECK:STDOUT: br !or.result(%x.ref)
// CHECK:STDOUT:
// CHECK:STDOUT: !or.result:
// CHECK:STDOUT: %.loc30_18.2: bool = block_arg !or.result [concrete = constants.%true]
// CHECK:STDOUT: if %.loc30_18.2 br !if.expr.then else br !if.expr.else
// CHECK:STDOUT: %.loc30_25.2: bool = block_arg !or.result [concrete = constants.%true]
// CHECK:STDOUT: if %.loc30_25.2 br !if.expr.then else br !if.expr.else
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then:
// CHECK:STDOUT: %Bool.call.loc30: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc30_28.1: type = value_of_initializer %Bool.call.loc30 [concrete = bool]
// CHECK:STDOUT: %.loc30_28.2: type = converted %Bool.call.loc30, %.loc30_28.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result(%.loc30_28.2)
// CHECK:STDOUT: %.loc30_35.1: type = value_of_initializer %Bool.call.loc30 [concrete = bool]
// CHECK:STDOUT: %.loc30_35.2: type = converted %Bool.call.loc30, %.loc30_35.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result(%.loc30_35.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else:
// CHECK:STDOUT: %.loc30_39: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_33: type = converted %.loc30_39, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result(%.loc30_33)
// CHECK:STDOUT: %.loc30_46: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc30_40: type = converted %.loc30_46, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result(%.loc30_40)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result:
// CHECK:STDOUT: %.loc30_10: type = block_arg !if.expr.result [concrete = bool]
// CHECK:STDOUT: br !.loc30_7
// CHECK:STDOUT: %.loc30_17: type = block_arg !if.expr.result [concrete = bool]
// CHECK:STDOUT: br !.loc30_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc30_7:
// CHECK:STDOUT: !.loc30_14:
// CHECK:STDOUT: %a: ref bool = ref_binding a, %a.var
// CHECK:STDOUT: %DestroyOp.bound: <bound method> = bound_method %a.var, constants.%DestroyOp.b0ebf8.2
// CHECK:STDOUT: %DestroyOp.call: init %empty_tuple.type = call %DestroyOp.bound(%a.var)
toolchain/check/testdata/operators/builtin/ref.carbon
Vendored
+8 -8
View File
@@ -30,14 +30,14 @@ library "[[@TEST_NAME]]";
fn F() {
var x: () = ();
// CHECK:STDERR: fail_ref_out_of_place.carbon:[[@LINE+4]]:15: error: `ref` tag is not an argument to a `ref` parameter [RefTagNoRefParam]
// CHECK:STDERR: let y: () = ref x;
// CHECK:STDERR: ^~~~~
// CHECK:STDERR: fail_ref_out_of_place.carbon:[[@LINE+4]]:22: error: `ref` tag is not an argument to a `ref` parameter [RefTagNoRefParam]
// CHECK:STDERR: let unused y: () = ref x;
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
let y: () = ref x;
// CHECK:STDERR: fail_ref_out_of_place.carbon:[[@LINE+4]]:16: error: `ref` tag is not an argument to a `ref` parameter [RefTagNoRefParam]
// CHECK:STDERR: let z: () = (ref x);
// CHECK:STDERR: ^~~~~
let unused y: () = ref x;
// CHECK:STDERR: fail_ref_out_of_place.carbon:[[@LINE+4]]:23: error: `ref` tag is not an argument to a `ref` parameter [RefTagNoRefParam]
// CHECK:STDERR: let unused z: () = (ref x);
// CHECK:STDERR: ^~~~~
// CHECK:STDERR:
let z: () = (ref x);
let unused z: () = (ref x);
}
toolchain/check/testdata/operators/builtin/unary_op.carbon
Vendored
+31 -31
View File
@@ -20,8 +20,8 @@ let not_true: bool = not true;
let not_false: bool = not false;
fn Constant() {
var a: if not true then bool else () = ();
var b: if not false then bool else () = true;
var unused a: if not true then bool else () = ();
var unused b: if not false then bool else () = true;
}
// CHECK:STDOUT: --- unary_op.carbon
@@ -137,33 +137,33 @@ fn Constant() {
// CHECK:STDOUT: %a.var_patt: %pattern_type.cb1 = var_pattern %a.patt [concrete]
// CHECK:STDOUT: }
// CHECK:STDOUT: %a.var: ref %empty_tuple.type = var %a.var_patt
// CHECK:STDOUT: %.loc23_43.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_43.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_3: init %empty_tuple.type = converted %.loc23_43.1, %.loc23_43.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_50.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_50.2: init %empty_tuple.type = tuple_init () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_3: init %empty_tuple.type = converted %.loc23_50.1, %.loc23_50.2 [concrete = constants.%empty_tuple]
// CHECK:STDOUT: assign %a.var, %.loc23_3
// CHECK:STDOUT: br !.loc23_17
// CHECK:STDOUT: br !.loc23_24
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_17:
// CHECK:STDOUT: !.loc23_24:
// CHECK:STDOUT: %true.loc23: bool = bool_literal true [concrete = constants.%true]
// CHECK:STDOUT: %.loc23_13: bool = not %true.loc23 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc23_13 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT: %.loc23_20: bool = not %true.loc23 [concrete = constants.%false]
// CHECK:STDOUT: if %.loc23_20 br !if.expr.then.loc23 else br !if.expr.else.loc23
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc23:
// CHECK:STDOUT: %Bool.call.loc23: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc23_27.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_27.2: type = converted %Bool.call.loc23, %.loc23_27.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_27.2)
// CHECK:STDOUT: %.loc23_34.1: type = value_of_initializer %Bool.call.loc23 [concrete = bool]
// CHECK:STDOUT: %.loc23_34.2: type = converted %Bool.call.loc23, %.loc23_34.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_34.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc23:
// CHECK:STDOUT: %.loc23_38: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_32: type = converted %.loc23_38, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_32)
// CHECK:STDOUT: %.loc23_45: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc23_39: type = converted %.loc23_45, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc23(%.loc23_39)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc23:
// CHECK:STDOUT: %.loc23_10: type = block_arg !if.expr.result.loc23 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc23_7
// CHECK:STDOUT: %.loc23_17: type = block_arg !if.expr.result.loc23 [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !.loc23_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc23_7:
// CHECK:STDOUT: !.loc23_14:
// CHECK:STDOUT: %a: ref %empty_tuple.type = ref_binding a, %a.var
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %b.patt: %pattern_type.831 = ref_binding_pattern b [concrete]
@@ -175,29 +175,29 @@ fn Constant() {
// CHECK:STDOUT: %bound_method: <bound method> = bound_method %true.loc24, %impl.elem0 [concrete = constants.%bool.as.Copy.impl.Op.bound]
// CHECK:STDOUT: %bool.as.Copy.impl.Op.call: init bool = call %bound_method(%true.loc24) [concrete = constants.%true]
// CHECK:STDOUT: assign %b.var, %bool.as.Copy.impl.Op.call
// CHECK:STDOUT: br !.loc24_17
// CHECK:STDOUT: br !.loc24_24
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_17:
// CHECK:STDOUT: !.loc24_24:
// CHECK:STDOUT: %false: bool = bool_literal false [concrete = constants.%false]
// CHECK:STDOUT: %.loc24_13: bool = not %false [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_13 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT: %.loc24_20: bool = not %false [concrete = constants.%true]
// CHECK:STDOUT: if %.loc24_20 br !if.expr.then.loc24 else br !if.expr.else.loc24
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.then.loc24:
// CHECK:STDOUT: %Bool.call.loc24: init type = call constants.%Bool() [concrete = bool]
// CHECK:STDOUT: %.loc24_28.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_28.2: type = converted %Bool.call.loc24, %.loc24_28.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_28.2)
// CHECK:STDOUT: %.loc24_35.1: type = value_of_initializer %Bool.call.loc24 [concrete = bool]
// CHECK:STDOUT: %.loc24_35.2: type = converted %Bool.call.loc24, %.loc24_35.1 [concrete = bool]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_35.2)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.else.loc24:
// CHECK:STDOUT: %.loc24_39: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_33: type = converted %.loc24_39, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_33)
// CHECK:STDOUT: %.loc24_46: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc24_40: type = converted %.loc24_46, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: br !if.expr.result.loc24(%.loc24_40)
// CHECK:STDOUT:
// CHECK:STDOUT: !if.expr.result.loc24:
// CHECK:STDOUT: %.loc24_10: type = block_arg !if.expr.result.loc24 [concrete = bool]
// CHECK:STDOUT: br !.loc24_7
// CHECK:STDOUT: %.loc24_17: type = block_arg !if.expr.result.loc24 [concrete = bool]
// CHECK:STDOUT: br !.loc24_14
// CHECK:STDOUT:
// CHECK:STDOUT: !.loc24_7:
// CHECK:STDOUT: !.loc24_14:
// CHECK:STDOUT: %b: ref bool = ref_binding b, %b.var
// CHECK:STDOUT: %DestroyOp.bound.loc24: <bound method> = bound_method %b.var, constants.%DestroyOp.b0ebf8.1
// CHECK:STDOUT: %DestroyOp.call.loc24: init %empty_tuple.type = call %DestroyOp.bound.loc24(%b.var)
toolchain/check/testdata/operators/overloaded/add.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.AddWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.AddAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/binary_op.carbon.tmpl
Vendored
+2 -2
View File
@@ -15,12 +15,12 @@ package User;
class C {};
impl C as Core.INTERFACEWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.INTERFACEAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/bit_and.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.BitAndWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.BitAndAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/bit_complement.carbon
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ package User;
class C {};
impl C as Core.BitComplement where .Result = C {
fn Op[self: C]() -> C {
fn Op[unused self: C]() -> C {
return {};
}
}
toolchain/check/testdata/operators/overloaded/bit_or.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.BitOrWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.BitOrAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/bit_xor.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.BitXorWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.BitXorAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/div.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.DivWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.DivAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/fail_no_impl_for_arg.carbon
Vendored
+2 -2
View File
@@ -16,10 +16,10 @@ class C {};
class D {};
impl C as Core.AddWith(C) where .Result = C {
fn Op[self: C](other: C) -> C { return {}; }
fn Op[unused self: C](unused other: C) -> C { return {}; }
}
impl C as Core.AddAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn Test(a: C, b: D, z: bool) -> C {
toolchain/check/testdata/operators/overloaded/index.carbon
Vendored
+7 -7
View File
@@ -58,7 +58,7 @@ import Core library "core_wrong_arg_count";
class C {}
impl C as Core.IndexWith((), ()) {
fn At[self: Self](subscript: ()) -> () {
fn At[unused self: Self](unused subscript: ()) -> () {
return ();
}
}
@@ -415,16 +415,16 @@ fn F() {
// CHECK:STDOUT: %return.patt: %pattern_type.cb1 = return_slot_pattern [concrete]
// CHECK:STDOUT: %return.param_patt: %pattern_type.cb1 = out_param_pattern %return.patt, call_param2 [concrete]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %.loc9_40.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_40.2: type = converted %.loc9_40.1, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: %.loc9_40.3: Core.Form = init_form %.loc9_40.2, call_param2 [concrete = constants.%.067]
// CHECK:STDOUT: %.loc9_54.1: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_54.2: type = converted %.loc9_54.1, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: %.loc9_54.3: Core.Form = init_form %.loc9_54.2, call_param2 [concrete = constants.%.067]
// CHECK:STDOUT: %self.param: %C = value_param call_param0
// CHECK:STDOUT: %Self.ref: type = name_ref Self, @C.as.IndexWith.impl.%C.ref [concrete = constants.%C]
// CHECK:STDOUT: %self: %C = value_binding self, %self.param
// CHECK:STDOUT: %subscript.param: %empty_tuple.type = value_param call_param1
// CHECK:STDOUT: %.loc9_33.1: type = splice_block %.loc9_33.3 [concrete = constants.%empty_tuple.type] {
// CHECK:STDOUT: %.loc9_33.2: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_33.3: type = converted %.loc9_33.2, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: %.loc9_47.1: type = splice_block %.loc9_47.3 [concrete = constants.%empty_tuple.type] {
// CHECK:STDOUT: %.loc9_47.2: %empty_tuple.type = tuple_literal () [concrete = constants.%empty_tuple]
// CHECK:STDOUT: %.loc9_47.3: type = converted %.loc9_47.2, constants.%empty_tuple.type [concrete = constants.%empty_tuple.type]
// CHECK:STDOUT: }
// CHECK:STDOUT: %subscript: %empty_tuple.type = value_binding subscript, %subscript.param
// CHECK:STDOUT: %return.param: ref %empty_tuple.type = out_param call_param2
toolchain/check/testdata/operators/overloaded/index_with_prelude.carbon
Vendored
+7 -7
View File
@@ -21,7 +21,7 @@ class ElementType {}
class SubscriptType {}
impl C as Core.IndexWith(SubscriptType) where .ElementType = ElementType {
fn At[self: Self](subscript: SubscriptType) -> ElementType {
fn At[unused self: Self](unused subscript: SubscriptType) -> ElementType {
return {};
}
}
@@ -39,7 +39,7 @@ class C {
}
impl (C, C) as Core.IndexWith(Core.IntLiteral()) where .ElementType = C {
fn At[self: Self](subscript: Core.IntLiteral()) -> C {
fn At[self: Self](unused subscript: Core.IntLiteral()) -> C {
return self.0;
}
}
@@ -56,7 +56,7 @@ class ElementType {}
class SubscriptType {}
impl C as Core.IndexWith(SubscriptType) where .ElementType = ElementType {
fn At[self: Self](subscript: SubscriptType) -> ElementType {
fn At[unused self: Self](unused subscript: SubscriptType) -> ElementType {
return {};
}
}
@@ -395,17 +395,17 @@ let x: i32 = c[0];
// CHECK:STDOUT: %return.param_patt: %pattern_type.7c7 = out_param_pattern %return.patt, call_param2 [concrete]
// CHECK:STDOUT: } {
// CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [concrete = constants.%C]
// CHECK:STDOUT: %.loc9_54: Core.Form = init_form %C.ref, call_param2 [concrete = constants.%.92f]
// CHECK:STDOUT: %.loc9_61: Core.Form = init_form %C.ref, call_param2 [concrete = constants.%.92f]
// CHECK:STDOUT: %self.param: %tuple.type.d23 = value_param call_param0
// CHECK:STDOUT: %Self.ref: type = name_ref Self, @tuple.type.as.IndexWith.impl.%.loc8_11.2 [concrete = constants.%tuple.type.d23]
// CHECK:STDOUT: %self: %tuple.type.d23 = value_binding self, %self.param
// CHECK:STDOUT: %subscript.param: Core.IntLiteral = value_param call_param1
// CHECK:STDOUT: %.loc9_48.1: type = splice_block %.loc9_48.3 [concrete = Core.IntLiteral] {
// CHECK:STDOUT: %.loc9_55.1: type = splice_block %.loc9_55.3 [concrete = Core.IntLiteral] {
// CHECK:STDOUT: %Core.ref: <namespace> = name_ref Core, imports.%Core [concrete = imports.%Core]
// CHECK:STDOUT: %IntLiteral.ref: %IntLiteral.type = name_ref IntLiteral, imports.%Core.IntLiteral [concrete = constants.%IntLiteral]
// CHECK:STDOUT: %IntLiteral.call: init type = call %IntLiteral.ref() [concrete = Core.IntLiteral]
// CHECK:STDOUT: %.loc9_48.2: type = value_of_initializer %IntLiteral.call [concrete = Core.IntLiteral]
// CHECK:STDOUT: %.loc9_48.3: type = converted %IntLiteral.call, %.loc9_48.2 [concrete = Core.IntLiteral]
// CHECK:STDOUT: %.loc9_55.2: type = value_of_initializer %IntLiteral.call [concrete = Core.IntLiteral]
// CHECK:STDOUT: %.loc9_55.3: type = converted %IntLiteral.call, %.loc9_55.2 [concrete = Core.IntLiteral]
// CHECK:STDOUT: }
// CHECK:STDOUT: %subscript: Core.IntLiteral = value_binding subscript, %subscript.param
// CHECK:STDOUT: %return.param: ref %C = out_param call_param2
toolchain/check/testdata/operators/overloaded/left_shift.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.LeftShiftWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.LeftShiftAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/mod.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.ModWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.ModAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/mul.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.MulWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.MulAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/negate.carbon
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ package User;
class C {};
impl C as Core.Negate where .Result = C {
fn Op[self: C]() -> C {
fn Op[unused self: C]() -> C {
return {};
}
}
toolchain/check/testdata/operators/overloaded/right_shift.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.RightShiftWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.RightShiftAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/string_indexing.carbon
Vendored
+30 -30
View File
@@ -14,22 +14,22 @@
library "[[@TEST_NAME]]";
fn TestLiteralNegativeIndex() {
// CHECK:STDERR: fail_literal_negative_index.carbon:[[@LINE+4]]:17: error: index `-1` is negative. [StringAtIndexNegative]
// CHECK:STDERR: let c: char = "Test"[-1];
// CHECK:STDERR: ^~~~~~~~~~
// CHECK:STDERR: fail_literal_negative_index.carbon:[[@LINE+4]]:24: error: index `-1` is negative. [StringAtIndexNegative]
// CHECK:STDERR: let unused c: char = "Test"[-1];
// CHECK:STDERR: ^~~~~~~~~~
// CHECK:STDERR:
let c: char = "Test"[-1];
let unused c: char = "Test"[-1];
}
// --- fail_literal_out_of_bounds.carbon
library "[[@TEST_NAME]]";
fn TestLiteralOutOfBounds() {
// CHECK:STDERR: fail_literal_out_of_bounds.carbon:[[@LINE+4]]:17: error: string index `4` is out of bounds; string has length 4. [StringAtIndexOutOfBounds]
// CHECK:STDERR: let c: char = "Test"[4];
// CHECK:STDERR: ^~~~~~~~~
// CHECK:STDERR: fail_literal_out_of_bounds.carbon:[[@LINE+4]]:24: error: string index `4` is out of bounds; string has length 4. [StringAtIndexOutOfBounds]
// CHECK:STDERR: let unused c: char = "Test"[4];
// CHECK:STDERR: ^~~~~~~~~
// CHECK:STDERR:
let c: char = "Test"[4];
let unused c: char = "Test"[4];
}
// --- fail_wrong_type.carbon
@@ -72,8 +72,8 @@ library "[[@TEST_NAME]]";
fn TestStringIndexing() {
//@dump-sem-ir-begin
let c: char = "Test"[0];
let d: char = "Test"[3];
let unused c: char = "Test"[0];
let unused d: char = "Test"[3];
//@dump-sem-ir-end
}
@@ -157,17 +157,17 @@ fn TestStringIndexing() {
// CHECK:STDOUT: %String.val.loc5: %str.ee0 = struct_value (%str.loc5, %int_4.loc5) [concrete = constants.%String.val]
// CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [concrete = constants.%int_0]
// CHECK:STDOUT: %impl.elem1.loc5: %.b7b = impl_witness_access constants.%IndexWith.impl_witness.8d4, element1 [concrete = constants.%str.as.IndexWith.impl.At.a70]
// CHECK:STDOUT: %bound_method.loc5_25.1: <bound method> = bound_method %String.val.loc5, %impl.elem1.loc5 [concrete = constants.%str.as.IndexWith.impl.At.bound]
// CHECK:STDOUT: %ImplicitAs.facet.loc5_25.1: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc5_25.1: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc5_25.1 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %ImplicitAs.facet.loc5_25.2: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc5_25.2: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc5_25.2 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %bound_method.loc5_32.1: <bound method> = bound_method %String.val.loc5, %impl.elem1.loc5 [concrete = constants.%str.as.IndexWith.impl.At.bound]
// CHECK:STDOUT: %ImplicitAs.facet.loc5_32.1: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc5_32.1: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc5_32.1 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %ImplicitAs.facet.loc5_32.2: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc5_32.2: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc5_32.2 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %specific_fn.loc5: <specific function> = specific_function %impl.elem1.loc5, @str.as.IndexWith.impl.At(constants.%ImplicitAs.facet) [concrete = constants.%str.as.IndexWith.impl.At.specific_fn]
// CHECK:STDOUT: %bound_method.loc5_25.2: <bound method> = bound_method %String.val.loc5, %specific_fn.loc5 [concrete = constants.%bound_method]
// CHECK:STDOUT: %str.as.IndexWith.impl.At.call.loc5: init %char = call %bound_method.loc5_25.2(%String.val.loc5, %int_0) [concrete = constants.%int_84]
// CHECK:STDOUT: %.loc5_25.3: %char = value_of_initializer %str.as.IndexWith.impl.At.call.loc5 [concrete = constants.%int_84]
// CHECK:STDOUT: %.loc5_25.4: %char = converted %str.as.IndexWith.impl.At.call.loc5, %.loc5_25.3 [concrete = constants.%int_84]
// CHECK:STDOUT: %c: %char = value_binding c, %.loc5_25.4
// CHECK:STDOUT: %bound_method.loc5_32.2: <bound method> = bound_method %String.val.loc5, %specific_fn.loc5 [concrete = constants.%bound_method]
// CHECK:STDOUT: %str.as.IndexWith.impl.At.call.loc5: init %char = call %bound_method.loc5_32.2(%String.val.loc5, %int_0) [concrete = constants.%int_84]
// CHECK:STDOUT: %.loc5_32.3: %char = value_of_initializer %str.as.IndexWith.impl.At.call.loc5 [concrete = constants.%int_84]
// CHECK:STDOUT: %.loc5_32.4: %char = converted %str.as.IndexWith.impl.At.call.loc5, %.loc5_32.3 [concrete = constants.%int_84]
// CHECK:STDOUT: %c: %char = value_binding c, %.loc5_32.4
// CHECK:STDOUT: name_binding_decl {
// CHECK:STDOUT: %d.patt: %pattern_type.b09 = value_binding_pattern d [concrete]
// CHECK:STDOUT: }
@@ -176,17 +176,17 @@ fn TestStringIndexing() {
// CHECK:STDOUT: %String.val.loc6: %str.ee0 = struct_value (%str.loc6, %int_4.loc6) [concrete = constants.%String.val]
// CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [concrete = constants.%int_3]
// CHECK:STDOUT: %impl.elem1.loc6: %.b7b = impl_witness_access constants.%IndexWith.impl_witness.8d4, element1 [concrete = constants.%str.as.IndexWith.impl.At.a70]
// CHECK:STDOUT: %bound_method.loc6_25.1: <bound method> = bound_method %String.val.loc6, %impl.elem1.loc6 [concrete = constants.%str.as.IndexWith.impl.At.bound]
// CHECK:STDOUT: %ImplicitAs.facet.loc6_25.1: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc6_25.1: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc6_25.1 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %ImplicitAs.facet.loc6_25.2: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc6_25.2: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc6_25.2 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %bound_method.loc6_32.1: <bound method> = bound_method %String.val.loc6, %impl.elem1.loc6 [concrete = constants.%str.as.IndexWith.impl.At.bound]
// CHECK:STDOUT: %ImplicitAs.facet.loc6_32.1: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc6_32.1: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc6_32.1 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %ImplicitAs.facet.loc6_32.2: %ImplicitAs.type.2ad = facet_value Core.IntLiteral, (constants.%ImplicitAs.impl_witness.4e6) [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %.loc6_32.2: %ImplicitAs.type.2ad = converted Core.IntLiteral, %ImplicitAs.facet.loc6_32.2 [concrete = constants.%ImplicitAs.facet]
// CHECK:STDOUT: %specific_fn.loc6: <specific function> = specific_function %impl.elem1.loc6, @str.as.IndexWith.impl.At(constants.%ImplicitAs.facet) [concrete = constants.%str.as.IndexWith.impl.At.specific_fn]
// CHECK:STDOUT: %bound_method.loc6_25.2: <bound method> = bound_method %String.val.loc6, %specific_fn.loc6 [concrete = constants.%bound_method]
// CHECK:STDOUT: %str.as.IndexWith.impl.At.call.loc6: init %char = call %bound_method.loc6_25.2(%String.val.loc6, %int_3) [concrete = constants.%int_116]
// CHECK:STDOUT: %.loc6_25.3: %char = value_of_initializer %str.as.IndexWith.impl.At.call.loc6 [concrete = constants.%int_116]
// CHECK:STDOUT: %.loc6_25.4: %char = converted %str.as.IndexWith.impl.At.call.loc6, %.loc6_25.3 [concrete = constants.%int_116]
// CHECK:STDOUT: %d: %char = value_binding d, %.loc6_25.4
// CHECK:STDOUT: %bound_method.loc6_32.2: <bound method> = bound_method %String.val.loc6, %specific_fn.loc6 [concrete = constants.%bound_method]
// CHECK:STDOUT: %str.as.IndexWith.impl.At.call.loc6: init %char = call %bound_method.loc6_32.2(%String.val.loc6, %int_3) [concrete = constants.%int_116]
// CHECK:STDOUT: %.loc6_32.3: %char = value_of_initializer %str.as.IndexWith.impl.At.call.loc6 [concrete = constants.%int_116]
// CHECK:STDOUT: %.loc6_32.4: %char = converted %str.as.IndexWith.impl.At.call.loc6, %.loc6_32.3 [concrete = constants.%int_116]
// CHECK:STDOUT: %d: %char = value_binding d, %.loc6_32.4
// CHECK:STDOUT: <elided>
// CHECK:STDOUT: }
// CHECK:STDOUT:
toolchain/check/testdata/operators/overloaded/sub.carbon
Vendored
+2 -2
View File
@@ -19,12 +19,12 @@ package User;
class C {};
impl C as Core.SubWith(C) where .Result = C {
fn Op[self: C](other: C) -> C {
fn Op[unused self: C](unused other: C) -> C {
return {};
}
}
impl C as Core.SubAssignWith(C) {
fn Op[ref self: C](other: C) {}
fn Op[unused ref self: C](unused other: C) {}
}
fn TestOp(a: C, b: C) -> C {
toolchain/check/testdata/operators/overloaded/unary_op.carbon.tmpl
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ package User;
class C {};
impl C as Core.INTERFACE where .Result = C {
fn Op[self: C]() -> C {
fn Op[unused self: C]() -> C {
return {};
}
}