1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 * # Compilation of match statements
15 * I will endeavor to explain the code as best I can. I have only a loose
16 * understanding of some parts of it.
20 * The basic state of the code is maintained in an array `m` of `@Match`
21 * objects. Each `@Match` describes some list of patterns, all of which must
22 * match against the current list of values. If those patterns match, then
23 * the arm listed in the match is the correct arm. A given arm may have
24 * multiple corresponding match entries, one for each alternative that
25 * remains. As we proceed these sets of matches are adjusted by the various
26 * `enter_XXX()` functions, each of which adjusts the set of options given
27 * some information about the value which has been matched.
29 * So, initially, there is one value and N matches, each of which have one
30 * constituent pattern. N here is usually the number of arms but may be
31 * greater, if some arms have multiple alternatives. For example, here:
33 * enum Foo { A, B(int), C(uint, uint) }
41 * The value would be `foo`. There would be four matches, each of which
42 * contains one pattern (and, in one case, a guard). We could collect the
43 * various options and then compile the code for the case where `foo` is an
44 * `A`, a `B`, and a `C`. When we generate the code for `C`, we would (1)
45 * drop the two matches that do not match a `C` and (2) expand the other two
46 * into two patterns each. In the first case, the two patterns would be `1u`
47 * and `2`, and the in the second case the _ pattern would be expanded into
48 * `_` and `_`. The two values are of course the arguments to `C`.
50 * Here is a quick guide to the various functions:
52 * - `compile_submatch()`: The main workhouse. It takes a list of values and
53 * a list of matches and finds the various possibilities that could occur.
55 * - `enter_XXX()`: modifies the list of matches based on some information
56 * about the value that has been matched. For example,
57 * `enter_rec_or_struct()` adjusts the values given that a record or struct
58 * has been matched. This is an infallible pattern, so *all* of the matches
59 * must be either wildcards or record/struct patterns. `enter_opt()`
60 * handles the fallible cases, and it is correspondingly more complex.
64 * We store information about the bound variables for each arm as part of the
65 * per-arm `ArmData` struct. There is a mapping from identifiers to
66 * `BindingInfo` structs. These structs contain the mode/id/type of the
67 * binding, but they also contain up to two LLVM values, called `llmatch` and
68 * `llbinding` respectively (the `llbinding`, as will be described shortly, is
69 * optional and only present for by-value bindings---therefore it is bundled
70 * up as part of the `TransBindingMode` type). Both point at allocas.
72 * The `llmatch` binding always stores a pointer into the value being matched
73 * which points at the data for the binding. If the value being matched has
74 * type `T`, then, `llmatch` will point at an alloca of type `T*` (and hence
75 * `llmatch` has type `T**`). So, if you have a pattern like:
79 * match (a, b) { (ref c, copy d) => { ... } }
81 * For `c` and `d`, we would generate allocas of type `C*` and `D*`
82 * respectively. These are called the `llmatch`. As we match, when we come
83 * up against an identifier, we store the current pointer into the
84 * corresponding alloca.
86 * In addition, for each by-value binding (copy or move), we will create a
87 * second alloca (`llbinding`) that will hold the final value. In this
88 * example, that means that `d` would have this second alloca of type `D` (and
89 * hence `llbinding` has type `D*`).
91 * Once a pattern is completely matched, and assuming that there is no guard
92 * pattern, we will branch to a block that leads to the body itself. For any
93 * by-value bindings, this block will first load the ptr from `llmatch` (the
94 * one of type `D*`) and copy/move the value into `llbinding` (the one of type
95 * `D`). The second alloca then becomes the value of the local variable. For
96 * by ref bindings, the value of the local variable is simply the first
99 * So, for the example above, we would generate a setup kind of like this:
105 * +-------------------------------------------+
106 * | llmatch_c = (addr of first half of tuple) |
107 * | llmatch_d = (addr of first half of tuple) |
108 * +-------------------------------------------+
110 * +--------------------------------------+
111 * | *llbinding_d = **llmatch_dlbinding_d |
112 * +--------------------------------------+
114 * If there is a guard, the situation is slightly different, because we must
115 * execute the guard code. Moreover, we need to do so once for each of the
116 * alternatives that lead to the arm, because if the guard fails, they may
117 * have different points from which to continue the search. Therefore, in that
118 * case, we generate code that looks more like:
124 * +-------------------------------------------+
125 * | llmatch_c = (addr of first half of tuple) |
126 * | llmatch_d = (addr of first half of tuple) |
127 * +-------------------------------------------+
129 * +-------------------------------------------------+
130 * | *llbinding_d = **llmatch_dlbinding_d |
131 * | check condition |
132 * | if false { free *llbinding_d, goto next case } |
133 * | if true { goto body } |
134 * +-------------------------------------------------+
136 * The handling for the cleanups is a bit... sensitive. Basically, the body
137 * is the one that invokes `add_clean()` for each binding. During the guard
138 * evaluation, we add temporary cleanups and revoke them after the guard is
139 * evaluated (it could fail, after all). Presuming the guard fails, we drop
140 * the various values we copied explicitly. Note that guards and moves are
141 * just plain incompatible.
145 use core::prelude::*;
148 use lib::llvm::{llvm, ValueRef, BasicBlockRef};
149 use middle::const_eval;
150 use middle::borrowck::root_map_key;
151 use middle::pat_util::*;
152 use middle::resolve::DefMap;
153 use middle::trans::adt;
154 use middle::trans::base::*;
155 use middle::trans::build::*;
156 use middle::trans::callee;
157 use middle::trans::common::*;
158 use middle::trans::consts;
159 use middle::trans::controlflow;
160 use middle::trans::datum;
161 use middle::trans::datum::*;
162 use middle::trans::expr::Dest;
163 use middle::trans::expr;
164 use middle::trans::glue;
165 use middle::trans::tvec;
166 use middle::trans::type_of;
168 use util::common::indenter;
170 use std::oldmap::HashMap;
172 use syntax::ast::ident;
173 use syntax::ast_util::path_to_ident;
174 use syntax::ast_util;
175 use syntax::codemap::{span, dummy_sp};
176 use syntax::print::pprust::pat_to_str;
178 // An option identifying a literal: either a unit-like struct or an
181 UnitLikeStructLit(ast::node_id), // the node ID of the pattern
183 ConstLit(ast::def_id), // the def ID of the constant
186 // An option identifying a branch (either a literal, a enum variant or a
190 var(/* disr val */int, @adt::Repr),
191 range(@ast::expr, @ast::expr),
193 vec_len_ge(uint, /* slice */uint)
196 pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool {
198 (&lit(a), &lit(b)) => {
200 (UnitLikeStructLit(a), UnitLikeStructLit(b)) => a == b,
204 ExprLit(existing_a_expr) => a_expr = existing_a_expr,
205 ConstLit(a_const) => {
206 let e = const_eval::lookup_const_by_id(tcx, a_const);
209 UnitLikeStructLit(_) => {
210 fail!(~"UnitLikeStructLit should have been handled \
217 ExprLit(existing_b_expr) => b_expr = existing_b_expr,
218 ConstLit(b_const) => {
219 let e = const_eval::lookup_const_by_id(tcx, b_const);
222 UnitLikeStructLit(_) => {
223 fail!(~"UnitLikeStructLit should have been handled \
228 const_eval::compare_lit_exprs(tcx, a_expr, b_expr) == 0
232 (&range(a1, a2), &range(b1, b2)) => {
233 const_eval::compare_lit_exprs(tcx, a1, b1) == 0 &&
234 const_eval::compare_lit_exprs(tcx, a2, b2) == 0
236 (&var(a, _), &var(b, _)) => a == b,
237 (&vec_len_eq(a), &vec_len_eq(b)) => a == b,
238 (&vec_len_ge(a, _), &vec_len_ge(b, _)) => a == b,
243 pub enum opt_result {
244 single_result(Result),
246 range_result(Result, Result),
248 pub fn trans_opt(bcx: block, o: &Opt) -> opt_result {
249 let _icx = bcx.insn_ctxt("match::trans_opt");
253 lit(ExprLit(lit_expr)) => {
254 let datumblock = expr::trans_to_datum(bcx, lit_expr);
255 return single_result(datumblock.to_result());
257 lit(UnitLikeStructLit(pat_id)) => {
258 let struct_ty = ty::node_id_to_type(bcx.tcx(), pat_id);
259 let datumblock = datum::scratch_datum(bcx, struct_ty, true);
260 return single_result(datumblock.to_result(bcx));
262 lit(ConstLit(lit_id)) => {
263 let llval = consts::get_const_val(bcx.ccx(), lit_id);
264 return single_result(rslt(bcx, llval));
266 var(disr_val, repr) => {
267 return adt::trans_case(bcx, repr, disr_val);
270 return range_result(rslt(bcx, consts::const_expr(ccx, l1)),
271 rslt(bcx, consts::const_expr(ccx, l2)));
274 return single_result(rslt(bcx, C_int(ccx, n as int)));
276 vec_len_ge(n, _) => {
277 return lower_bound(rslt(bcx, C_int(ccx, n as int)));
282 pub fn variant_opt(bcx: block, pat_id: ast::node_id)
285 match ccx.tcx.def_map.get(&pat_id) {
286 ast::def_variant(enum_id, var_id) => {
287 let variants = ty::enum_variants(ccx.tcx, enum_id);
288 for vec::each(*variants) |v| {
290 return var(v.disr_val,
291 adt::represent_node(bcx, pat_id))
294 ::core::util::unreachable();
296 ast::def_struct(_) => {
297 return lit(UnitLikeStructLit(pat_id));
300 ccx.sess.bug(~"non-variant or struct in variant_opt()");
305 pub enum TransBindingMode {
306 TrByValue(/*ismove:*/ bool, /*llbinding:*/ ValueRef),
312 * Information about a pattern binding:
313 * - `llmatch` is a pointer to a stack slot. The stack slot contains a
314 * pointer into the value being matched. Hence, llmatch has type `T**`
315 * where `T` is the value being matched.
316 * - `trmode` is the trans binding mode
317 * - `id` is the node id of the binding
318 * - `ty` is the Rust type of the binding */
319 pub struct BindingInfo {
321 trmode: TransBindingMode,
326 pub type BindingsMap = HashMap<ident, BindingInfo>;
330 arm: &'self ast::arm,
331 bindings_map: BindingsMap
339 pub fn match_to_str(bcx: block, m: &Match) -> ~str {
340 if bcx.sess().verbose() {
341 // for many programs, this just take too long to serialize
342 fmt!("%?", m.pats.map(|p| pat_to_str(*p, bcx.sess().intr())))
344 fmt!("%u pats", m.pats.len())
348 pub fn matches_to_str(bcx: block, m: &[@Match]) -> ~str {
349 fmt!("%?", m.map(|n| match_to_str(bcx, *n)))
352 pub fn has_nested_bindings(m: &[@Match], col: uint) -> bool {
353 for vec::each(m) |br| {
354 match br.pats[col].node {
355 ast::pat_ident(_, _, Some(_)) => return true,
362 pub fn expand_nested_bindings(bcx: block, m: &[@Match/&r],
363 col: uint, val: ValueRef)
365 debug!("expand_nested_bindings(bcx=%s, m=%s, col=%u, val=%?)",
367 matches_to_str(bcx, m),
370 let _indenter = indenter();
373 match br.pats[col].node {
374 ast::pat_ident(_, path, Some(inner)) => {
375 let pats = vec::append(
376 vec::slice(br.pats, 0u, col).to_vec(),
377 vec::append(~[inner],
378 vec::slice(br.pats, col + 1u,
382 br.data.bindings_map.get(&path_to_ident(path));
384 Store(bcx, val, binding_info.llmatch);
385 @Match {pats: pats, data: br.data}
394 pub type enter_pat = &'self fn(@ast::pat) -> Option<~[@ast::pat]>;
396 pub fn assert_is_binding_or_wild(bcx: block, p: @ast::pat) {
397 if !pat_is_binding_or_wild(bcx.tcx().def_map, p) {
400 fmt!("Expected an identifier pattern but found p: %s",
401 pat_to_str(p, bcx.sess().intr())));
405 pub fn enter_match(bcx: block, dm: DefMap, m: &[@Match/&r],
406 col: uint, val: ValueRef, e: enter_pat)
408 debug!("enter_match(bcx=%s, m=%s, col=%u, val=%?)",
410 matches_to_str(bcx, m),
413 let _indenter = indenter();
415 let mut result = ~[];
416 for vec::each(m) |br| {
417 match e(br.pats[col]) {
421 vec::append(sub, vec::slice(br.pats, 0u, col)),
422 vec::slice(br.pats, col + 1u, br.pats.len()));
424 let self = br.pats[col];
426 ast::pat_ident(_, path, None) => {
427 if pat_is_binding(dm, self) {
429 br.data.bindings_map.get(
430 &path_to_ident(path));
431 Store(bcx, val, binding_info.llmatch);
437 result.push(@Match {pats: pats, data: br.data});
443 debug!("result=%s", matches_to_str(bcx, result));
448 pub fn enter_default(bcx: block, dm: DefMap, m: &[@Match/&r],
449 col: uint, val: ValueRef)
451 debug!("enter_default(bcx=%s, m=%s, col=%u, val=%?)",
453 matches_to_str(bcx, m),
456 let _indenter = indenter();
458 do enter_match(bcx, dm, m, col, val) |p| {
460 ast::pat_wild | ast::pat_tup(_) | ast::pat_struct(*) => Some(~[]),
461 ast::pat_ident(_, _, None) if pat_is_binding(dm, p) => Some(~[]),
467 // <pcwalton> nmatsakis: what does enter_opt do?
468 // <pcwalton> in trans/match
469 // <pcwalton> trans/match.rs is like stumbling around in a dark cave
470 // <nmatsakis> pcwalton: the enter family of functions adjust the set of
471 // patterns as needed
472 // <nmatsakis> yeah, at some point I kind of achieved some level of
474 // <nmatsakis> anyhow, they adjust the patterns given that something of that
475 // kind has been found
476 // <nmatsakis> pcwalton: ok, right, so enter_XXX() adjusts the patterns, as I
478 // <nmatsakis> enter_match() kind of embodies the generic code
479 // <nmatsakis> it is provided with a function that tests each pattern to see
480 // if it might possibly apply and so forth
481 // <nmatsakis> so, if you have a pattern like {a: _, b: _, _} and one like _
482 // <nmatsakis> then _ would be expanded to (_, _)
483 // <nmatsakis> one spot for each of the sub-patterns
484 // <nmatsakis> enter_opt() is one of the more complex; it covers the fallible
486 // <nmatsakis> enter_rec_or_struct() or enter_tuple() are simpler, since they
487 // are infallible patterns
488 // <nmatsakis> so all patterns must either be records (resp. tuples) or
491 pub fn enter_opt(bcx: block, m: &[@Match/&r], opt: &Opt, col: uint,
492 variant_size: uint, val: ValueRef)
494 debug!("enter_opt(bcx=%s, m=%s, col=%u, val=%?)",
496 matches_to_str(bcx, m),
499 let _indenter = indenter();
502 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
503 do enter_match(bcx, tcx.def_map, m, col, val) |p| {
506 ast::pat_ident(_, _, None) if pat_is_const(tcx.def_map, p) => {
507 let const_def = tcx.def_map.get(&p.id);
508 let const_def_id = ast_util::def_id_of_def(const_def);
509 if opt_eq(tcx, &lit(ConstLit(const_def_id)), opt) {
515 ast::pat_enum(_, ref subpats) => {
516 if opt_eq(tcx, &variant_opt(bcx, p.id), opt) {
518 None => Some(vec::from_elem(variant_size, dummy)),
525 ast::pat_ident(_, _, None)
526 if pat_is_variant_or_struct(tcx.def_map, p) => {
527 if opt_eq(tcx, &variant_opt(bcx, p.id), opt) {
534 if opt_eq(tcx, &lit(ExprLit(l)), opt) {Some(~[])} else {None}
536 ast::pat_range(l1, l2) => {
537 if opt_eq(tcx, &range(l1, l2), opt) {Some(~[])} else {None}
539 ast::pat_struct(_, ref field_pats, _) => {
540 if opt_eq(tcx, &variant_opt(bcx, p.id), opt) {
541 // Look up the struct variant ID.
543 match tcx.def_map.get(&p.id) {
544 ast::def_variant(_, found_struct_id) => {
545 struct_id = found_struct_id;
548 tcx.sess.span_bug(p.span, ~"expected enum \
553 // Reorder the patterns into the same order they were
554 // specified in the struct definition. Also fill in
555 // unspecified fields with dummy.
556 let mut reordered_patterns = ~[];
557 for ty::lookup_struct_fields(tcx, struct_id).each
559 match field_pats.find(|p|
560 p.ident == field.ident) {
561 None => reordered_patterns.push(dummy),
562 Some(fp) => reordered_patterns.push(fp.pat)
565 Some(reordered_patterns)
570 ast::pat_vec(ref before, slice, ref after) => {
573 let n = before.len() + after.len();
574 let i = before.len();
575 if opt_eq(tcx, &vec_len_ge(n, i), opt) {
576 Some(vec::append_one(copy *before, slice) +
583 let n = before.len();
584 if opt_eq(tcx, &vec_len_eq(n), opt) {
593 assert_is_binding_or_wild(bcx, p);
594 Some(vec::from_elem(variant_size, dummy))
600 pub fn enter_rec_or_struct(bcx: block,
604 fields: &[ast::ident],
607 debug!("enter_rec_or_struct(bcx=%s, m=%s, col=%u, val=%?)",
609 matches_to_str(bcx, m),
612 let _indenter = indenter();
614 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
615 do enter_match(bcx, dm, m, col, val) |p| {
617 ast::pat_struct(_, ref fpats, _) => {
619 for fields.each |fname| {
620 match fpats.find(|p| p.ident == *fname) {
621 None => pats.push(dummy),
622 Some(pat) => pats.push(pat.pat)
628 assert_is_binding_or_wild(bcx, p);
629 Some(vec::from_elem(fields.len(), dummy))
635 pub fn enter_tup(bcx: block, dm: DefMap, m: &[@Match/&r],
636 col: uint, val: ValueRef, n_elts: uint)
638 debug!("enter_tup(bcx=%s, m=%s, col=%u, val=%?)",
640 matches_to_str(bcx, m),
643 let _indenter = indenter();
645 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
646 do enter_match(bcx, dm, m, col, val) |p| {
648 ast::pat_tup(/*bad*/copy elts) => {
652 assert_is_binding_or_wild(bcx, p);
653 Some(vec::from_elem(n_elts, dummy))
659 pub fn enter_tuple_struct(bcx: block,
666 debug!("enter_tuple_struct(bcx=%s, m=%s, col=%u, val=%?)",
668 matches_to_str(bcx, m),
671 let _indenter = indenter();
673 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
674 do enter_match(bcx, dm, m, col, val) |p| {
676 ast::pat_enum(_, Some(/*bad*/copy elts)) => Some(elts),
678 assert_is_binding_or_wild(bcx, p);
679 Some(vec::from_elem(n_elts, dummy))
685 pub fn enter_box(bcx: block,
691 debug!("enter_box(bcx=%s, m=%s, col=%u, val=%?)",
693 matches_to_str(bcx, m),
696 let _indenter = indenter();
698 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
699 do enter_match(bcx, dm, m, col, val) |p| {
701 ast::pat_box(sub) => {
705 assert_is_binding_or_wild(bcx, p);
712 pub fn enter_uniq(bcx: block,
718 debug!("enter_uniq(bcx=%s, m=%s, col=%u, val=%?)",
720 matches_to_str(bcx, m),
723 let _indenter = indenter();
725 let dummy = @ast::pat {id: 0, node: ast::pat_wild, span: dummy_sp()};
726 do enter_match(bcx, dm, m, col, val) |p| {
728 ast::pat_uniq(sub) => {
732 assert_is_binding_or_wild(bcx, p);
739 pub fn enter_region(bcx: block,
745 debug!("enter_region(bcx=%s, m=%s, col=%u, val=%?)",
747 matches_to_str(bcx, m),
750 let _indenter = indenter();
752 let dummy = @ast::pat { id: 0, node: ast::pat_wild, span: dummy_sp() };
753 do enter_match(bcx, dm, m, col, val) |p| {
755 ast::pat_region(sub) => {
759 assert_is_binding_or_wild(bcx, p);
766 // Returns the options in one column of matches. An option is something that
767 // needs to be conditionally matched at runtime; for example, the discriminant
768 // on a set of enum variants or a literal.
769 pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
771 fn add_to_set(tcx: ty::ctxt, set: &mut ~[Opt], +val: Opt) {
772 if set.any(|l| opt_eq(tcx, l, &val)) {return;}
778 let cur = br.pats[col];
781 add_to_set(ccx.tcx, &mut found, lit(ExprLit(l)));
783 ast::pat_ident(*) => {
784 // This is one of: an enum variant, a unit-like struct, or a
786 match ccx.tcx.def_map.find(&cur.id) {
787 Some(ast::def_variant(*)) => {
788 add_to_set(ccx.tcx, &mut found,
789 variant_opt(bcx, cur.id));
791 Some(ast::def_struct(*)) => {
792 add_to_set(ccx.tcx, &mut found,
793 lit(UnitLikeStructLit(cur.id)));
795 Some(ast::def_const(const_did)) => {
796 add_to_set(ccx.tcx, &mut found,
797 lit(ConstLit(const_did)));
802 ast::pat_enum(*) | ast::pat_struct(*) => {
803 // This could be one of: a tuple-like enum variant, a
804 // struct-like enum variant, or a struct.
805 match ccx.tcx.def_map.find(&cur.id) {
806 Some(ast::def_variant(*)) => {
807 add_to_set(ccx.tcx, &mut found,
808 variant_opt(bcx, cur.id));
810 Some(ast::def_const(const_did)) => {
811 add_to_set(ccx.tcx, &mut found,
812 lit(ConstLit(const_did)));
817 ast::pat_range(l1, l2) => {
818 add_to_set(ccx.tcx, &mut found, range(l1, l2));
820 ast::pat_vec(ref before, slice, ref after) => {
821 let opt = match slice {
822 None => vec_len_eq(before.len()),
823 Some(_) => vec_len_ge(before.len() + after.len(),
826 add_to_set(ccx.tcx, &mut found, opt);
834 pub struct ExtractedBlock {
839 pub fn extract_variant_args(bcx: block,
844 let _icx = bcx.insn_ctxt("match::extract_variant_args");
845 let args = do vec::from_fn(adt::num_args(repr, disr_val)) |i| {
846 adt::trans_field_ptr(bcx, repr, val, disr_val, i)
849 ExtractedBlock { vals: args, bcx: bcx }
852 pub fn extract_vec_elems(bcx: block,
853 pat_id: ast::node_id,
859 let _icx = bcx.insn_ctxt("match::extract_vec_elems");
860 let vt = tvec::vec_types(bcx, node_id_type(bcx, pat_id));
861 let unboxed = load_if_immediate(bcx, val, vt.vec_ty);
862 let (base, len) = tvec::get_base_and_len(bcx, unboxed, vt.vec_ty);
864 let mut elems = do vec::from_fn(elem_count) |i| {
866 None => GEPi(bcx, base, ~[i]),
867 Some(n) if i < n => GEPi(bcx, base, ~[i]),
868 Some(n) if i > n => {
869 InBoundsGEP(bcx, base, ~[
871 C_int(bcx.ccx(), (elem_count - i) as int))])
873 _ => unsafe { llvm::LLVMGetUndef(vt.llunit_ty) }
878 let slice_offset = Mul(bcx, vt.llunit_size,
879 C_int(bcx.ccx(), n as int)
881 let slice_begin = tvec::pointer_add(bcx, base, slice_offset);
882 let slice_len_offset = Mul(bcx, vt.llunit_size,
883 C_int(bcx.ccx(), (elem_count - 1u) as int)
885 let slice_len = Sub(bcx, len, slice_len_offset);
886 let slice_ty = ty::mk_evec(bcx.tcx(),
887 ty::mt {ty: vt.unit_ty, mutbl: ast::m_imm},
888 ty::vstore_slice(ty::re_static)
890 let scratch = scratch_datum(bcx, slice_ty, false);
891 Store(bcx, slice_begin,
892 GEPi(bcx, scratch.val, [0u, abi::slice_elt_base])
894 Store(bcx, slice_len,
895 GEPi(bcx, scratch.val, [0u, abi::slice_elt_len])
897 elems[n] = scratch.val;
898 scratch.add_clean(bcx);
901 ExtractedBlock { vals: elems, bcx: bcx }
904 // NB: This function does not collect fields from struct-like enum variants.
905 pub fn collect_record_or_struct_fields(bcx: block,
909 let mut fields: ~[ast::ident] = ~[];
910 for vec::each(m) |br| {
911 match br.pats[col].node {
912 ast::pat_struct(_, ref fs, _) => {
913 match ty::get(node_id_type(bcx, br.pats[col].id)).sty {
914 ty::ty_struct(*) => extend(&mut fields, *fs),
923 fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) {
924 for field_pats.each |field_pat| {
925 let field_ident = field_pat.ident;
926 if !vec::any(*idents, |x| *x == field_ident) {
927 idents.push(field_ident);
933 pub fn root_pats_as_necessary(bcx: block,
939 for vec::each(m) |br| {
940 let pat_id = br.pats[col].id;
942 let key = root_map_key {id: pat_id, derefs: 0u };
943 match bcx.ccx().maps.root_map.find(&key) {
946 // Note: the scope_id will always be the id of the match. See
947 // the extended comment in rustc::middle::borrowck::preserve()
948 // for details (look for the case covering cat_discr).
950 let datum = Datum {val: val, ty: node_id_type(bcx, pat_id),
951 mode: ByRef, source: ZeroMem};
952 bcx = datum.root(bcx, root_info);
953 // If we kept going, we'd only re-root the same value, so
962 // Macro for deciding whether any of the remaining matches fit a given kind of
963 // pattern. Note that, because the macro is well-typed, either ALL of the
964 // matches should fit that sort of pattern or NONE (however, some of the
965 // matches may be wildcards like _ or identifiers).
966 macro_rules! any_pat (
967 ($m:expr, $pattern:pat) => (
969 match br.pats[col].node {
977 pub fn any_box_pat(m: &[@Match], col: uint) -> bool {
978 any_pat!(m, ast::pat_box(_))
981 pub fn any_uniq_pat(m: &[@Match], col: uint) -> bool {
982 any_pat!(m, ast::pat_uniq(_))
985 pub fn any_region_pat(m: &[@Match], col: uint) -> bool {
986 any_pat!(m, ast::pat_region(_))
989 pub fn any_tup_pat(m: &[@Match], col: uint) -> bool {
990 any_pat!(m, ast::pat_tup(_))
993 pub fn any_tuple_struct_pat(bcx: block, m: &[@Match], col: uint) -> bool {
995 let pat = br.pats[col];
997 ast::pat_enum(_, Some(_)) => {
998 match bcx.tcx().def_map.find(&pat.id) {
999 Some(ast::def_struct(*)) => true,
1008 pub type mk_fail = @fn() -> BasicBlockRef;
1010 pub fn pick_col(m: &[@Match]) -> uint {
1011 fn score(p: @ast::pat) -> uint {
1013 ast::pat_lit(_) | ast::pat_enum(_, _) | ast::pat_range(_, _) => 1u,
1014 ast::pat_ident(_, _, Some(p)) => score(p),
1018 let mut scores = vec::from_elem(m[0].pats.len(), 0u);
1019 for vec::each(m) |br| {
1021 for vec::each(br.pats) |p| { scores[i] += score(*p); i += 1u; }
1023 let mut max_score = 0u;
1024 let mut best_col = 0u;
1026 for vec::each(scores) |score| {
1029 // Irrefutable columns always go first, they'd only be duplicated in
1031 if score == 0u { return i; }
1032 // If no irrefutable ones are found, we pick the one with the biggest
1033 // branching factor.
1034 if score > max_score { max_score = score; best_col = i; }
1041 pub enum branch_kind { no_branch, single, switch, compare, compare_vec_len, }
1043 // Compiles a comparison between two things.
1045 // NB: This must produce an i1, not a Rust bool (i8).
1046 pub fn compare_values(cx: block,
1051 let _icx = cx.insn_ctxt("compare_values");
1052 if ty::type_is_scalar(rhs_t) {
1053 let rs = compare_scalar_types(cx, lhs, rhs, rhs_t, ast::eq);
1054 return rslt(rs.bcx, rs.val);
1057 match ty::get(rhs_t).sty {
1058 ty::ty_estr(ty::vstore_uniq) => {
1059 let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
1061 let scratch_lhs = alloca(cx, val_ty(lhs));
1062 Store(cx, lhs, scratch_lhs);
1063 let scratch_rhs = alloca(cx, val_ty(rhs));
1064 Store(cx, rhs, scratch_rhs);
1065 let did = cx.tcx().lang_items.uniq_str_eq_fn();
1066 let bcx = callee::trans_lang_call(cx, did,
1070 scratch_result.val));
1071 let result = scratch_result.to_result(bcx);
1074 val: bool_to_i1(result.bcx, result.val)
1078 let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
1080 let did = cx.tcx().lang_items.str_eq_fn();
1081 let bcx = callee::trans_lang_call(cx, did,
1084 scratch_result.val));
1085 let result = scratch_result.to_result(bcx);
1088 val: bool_to_i1(result.bcx, result.val)
1092 cx.tcx().sess.bug(~"only scalars and strings supported in \
1098 pub fn store_non_ref_bindings(bcx: block,
1100 opt_temp_cleanups: Option<&mut ~[ValueRef]>)
1104 * For each copy/move binding, copy the value from the value
1105 * being matched into its final home. This code executes once
1106 * one of the patterns for a given arm has completely matched.
1107 * It adds temporary cleanups to the `temp_cleanups` array,
1108 * if one is provided.
1112 for data.bindings_map.each_value |&binding_info| {
1113 match binding_info.trmode {
1114 TrByValue(is_move, lldest) => {
1115 let llval = Load(bcx, binding_info.llmatch); // get a T*
1116 let datum = Datum {val: llval, ty: binding_info.ty,
1117 mode: ByRef, source: ZeroMem};
1120 datum.move_to(bcx, INIT, lldest)
1122 datum.copy_to(bcx, INIT, lldest)
1126 for opt_temp_cleanups.each |temp_cleanups| {
1127 add_clean_temp_mem(bcx, lldest, binding_info.ty);
1128 temp_cleanups.push(lldest);
1131 TrByRef | TrByImplicitRef => {}
1137 pub fn insert_lllocals(bcx: block,
1139 add_cleans: bool) -> block {
1142 * For each binding in `data.bindings_map`, adds an appropriate entry into
1143 * the `fcx.lllocals` map. If add_cleans is true, then adds cleanups for
1146 for data.bindings_map.each_value |&binding_info| {
1147 let llval = match binding_info.trmode {
1148 // By value bindings: use the stack slot that we
1149 // copied/moved the value into
1150 TrByValue(_, lldest) => {
1152 add_clean(bcx, lldest, binding_info.ty);
1158 // By ref binding: use the ptr into the matched value
1160 binding_info.llmatch
1163 // Ugly: for implicit ref, we actually want a T*, but
1164 // we have a T**, so we had to load. This will go away
1165 // once implicit refs go away.
1166 TrByImplicitRef => {
1167 Load(bcx, binding_info.llmatch)
1171 bcx.fcx.lllocals.insert(binding_info.id,
1177 pub fn compile_guard(bcx: block,
1178 guard_expr: @ast::expr,
1182 chk: Option<mk_fail>)
1184 debug!("compile_guard(bcx=%s, guard_expr=%s, m=%s, vals=%?)",
1186 bcx.expr_to_str(guard_expr),
1187 matches_to_str(bcx, m),
1188 vals.map(|v| bcx.val_str(*v)));
1189 let _indenter = indenter();
1192 let mut temp_cleanups = ~[];
1193 bcx = store_non_ref_bindings(bcx, data, Some(&mut temp_cleanups));
1194 bcx = insert_lllocals(bcx, data, false);
1196 let val = unpack_result!(bcx, {
1197 do with_scope_result(bcx, guard_expr.info(),
1199 expr::trans_to_datum(bcx, guard_expr).to_result()
1202 let val = bool_to_i1(bcx, val);
1204 // Revoke the temp cleanups now that the guard successfully executed.
1205 for temp_cleanups.each |llval| {
1206 revoke_clean(bcx, *llval);
1209 return do with_cond(bcx, Not(bcx, val)) |bcx| {
1210 // Guard does not match: free the values we copied,
1211 // and remove all bindings from the lllocals table
1212 let bcx = drop_bindings(bcx, data);
1213 compile_submatch(bcx, m, vals, chk);
1217 fn drop_bindings(bcx: block, data: &ArmData) -> block {
1219 for data.bindings_map.each_value |&binding_info| {
1220 match binding_info.trmode {
1221 TrByValue(_, llval) => {
1222 bcx = glue::drop_ty(bcx, llval, binding_info.ty);
1224 TrByRef | TrByImplicitRef => {}
1226 bcx.fcx.lllocals.remove(&binding_info.id);
1232 pub fn compile_submatch(bcx: block,
1235 chk: Option<mk_fail>) {
1236 debug!("compile_submatch(bcx=%s, m=%s, vals=%?)",
1238 matches_to_str(bcx, m),
1239 vals.map(|v| bcx.val_str(*v)));
1240 let _indenter = indenter();
1243 For an empty match, a fall-through case must exist
1245 fail_unless!((m.len() > 0u || chk.is_some()));
1246 let _icx = bcx.insn_ctxt("match::compile_submatch");
1248 let tcx = bcx.tcx(), dm = tcx.def_map;
1250 Br(bcx, chk.get()());
1253 if m[0].pats.len() == 0u {
1254 let data = m[0].data;
1255 match data.arm.guard {
1256 Some(guard_expr) => {
1257 bcx = compile_guard(bcx, guard_expr, m[0].data,
1258 vec::slice(m, 1, m.len()),
1263 Br(bcx, data.bodycx.llbb);
1267 let col = pick_col(m);
1268 let val = vals[col];
1270 if has_nested_bindings(m, col) {
1271 expand_nested_bindings(bcx, m, col, val)
1277 let vals_left = vec::append(vec::slice(vals, 0u, col).to_vec(),
1278 vec::slice(vals, col + 1u, vals.len()));
1279 let ccx = *bcx.fcx.ccx;
1281 for vec::each(m) |br| {
1282 // Find a real id (we're adding placeholder wildcard patterns, but
1283 // each column is guaranteed to have at least one real pattern)
1284 if pat_id == 0 { pat_id = br.pats[col].id; }
1287 bcx = root_pats_as_necessary(bcx, m, col, val);
1288 let rec_fields = collect_record_or_struct_fields(bcx, m, col);
1289 if rec_fields.len() > 0 {
1290 let pat_ty = node_id_type(bcx, pat_id);
1291 let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
1292 do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
1293 let rec_vals = rec_fields.map(|field_name| {
1294 let ix = ty::field_idx_strict(tcx, *field_name, field_tys);
1295 adt::trans_field_ptr(bcx, pat_repr, val, discr, ix)
1299 enter_rec_or_struct(bcx, dm, m, col, rec_fields, val),
1300 vec::append(rec_vals, vals_left),
1306 if any_tup_pat(m, col) {
1307 let tup_ty = node_id_type(bcx, pat_id);
1308 let tup_repr = adt::represent_type(bcx.ccx(), tup_ty);
1309 let n_tup_elts = match ty::get(tup_ty).sty {
1310 ty::ty_tup(ref elts) => elts.len(),
1311 _ => ccx.sess.bug(~"non-tuple type in tuple pattern")
1313 let tup_vals = do vec::from_fn(n_tup_elts) |i| {
1314 adt::trans_field_ptr(bcx, tup_repr, val, 0, i)
1316 compile_submatch(bcx, enter_tup(bcx, dm, m, col, val, n_tup_elts),
1317 vec::append(tup_vals, vals_left), chk);
1321 if any_tuple_struct_pat(bcx, m, col) {
1322 let struct_ty = node_id_type(bcx, pat_id);
1323 let struct_element_count;
1324 match ty::get(struct_ty).sty {
1325 ty::ty_struct(struct_id, _) => {
1326 struct_element_count =
1327 ty::lookup_struct_fields(tcx, struct_id).len();
1330 ccx.sess.bug(~"non-struct type in tuple struct pattern");
1334 let struct_repr = adt::represent_type(bcx.ccx(), struct_ty);
1335 let llstructvals = do vec::from_fn(struct_element_count) |i| {
1336 adt::trans_field_ptr(bcx, struct_repr, val, 0, i)
1338 compile_submatch(bcx,
1339 enter_tuple_struct(bcx, dm, m, col, val,
1340 struct_element_count),
1341 vec::append(llstructvals, vals_left),
1346 // Unbox in case of a box field
1347 if any_box_pat(m, col) {
1348 let llbox = Load(bcx, val);
1349 let box_no_addrspace = non_gc_box_cast(bcx, llbox);
1351 GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
1352 compile_submatch(bcx, enter_box(bcx, dm, m, col, val),
1353 vec::append(~[unboxed], vals_left), chk);
1357 if any_uniq_pat(m, col) {
1358 let llbox = Load(bcx, val);
1359 let box_no_addrspace = non_gc_box_cast(bcx, llbox);
1361 GEPi(bcx, box_no_addrspace, [0u, abi::box_field_body]);
1362 compile_submatch(bcx, enter_uniq(bcx, dm, m, col, val),
1363 vec::append(~[unboxed], vals_left), chk);
1367 if any_region_pat(m, col) {
1368 let loaded_val = Load(bcx, val);
1369 compile_submatch(bcx, enter_region(bcx, dm, m, col, val),
1370 vec::append(~[loaded_val], vals_left), chk);
1374 // Decide what kind of branch we need
1375 let opts = get_options(bcx, m, col);
1376 let mut kind = no_branch;
1377 let mut test_val = val;
1378 if opts.len() > 0u {
1381 let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val);
1383 for val_opt.each |&tval| { test_val = tval; }
1386 let pty = node_id_type(bcx, pat_id);
1387 test_val = load_if_immediate(bcx, val, pty);
1388 kind = if ty::type_is_integral(pty) { switch }
1392 test_val = Load(bcx, val);
1395 vec_len_eq(*) | vec_len_ge(*) => {
1396 let vt = tvec::vec_types(bcx, node_id_type(bcx, pat_id));
1397 let unboxed = load_if_immediate(bcx, val, vt.vec_ty);
1398 let (_, len) = tvec::get_base_and_len(
1399 bcx, unboxed, vt.vec_ty
1401 test_val = SDiv(bcx, len, vt.llunit_size);
1402 kind = compare_vec_len;
1406 for vec::each(opts) |o| {
1408 range(_, _) => { kind = compare; break }
1412 let else_cx = match kind {
1413 no_branch | single => bcx,
1414 _ => sub_block(bcx, ~"match_else")
1416 let sw = if kind == switch {
1417 Switch(bcx, test_val, else_cx.llbb, opts.len())
1419 C_int(ccx, 0) // Placeholder for when not using a switch
1422 let defaults = enter_default(else_cx, dm, m, col, val);
1423 let exhaustive = chk.is_none() && defaults.len() == 0u;
1424 let len = opts.len();
1427 // Compile subtrees for each option
1428 for vec::each(opts) |opt| {
1430 let mut opt_cx = else_cx;
1431 if !exhaustive || i < len {
1432 opt_cx = sub_block(bcx, ~"match_case");
1434 single => Br(bcx, opt_cx.llbb),
1436 match trans_opt(bcx, opt) {
1437 single_result(r) => {
1439 llvm::LLVMAddCase(sw, r.val, opt_cx.llbb);
1445 ~"in compile_submatch, expected \
1446 trans_opt to return a single_result")
1451 let t = node_id_type(bcx, pat_id);
1452 let Result {bcx: after_cx, val: matches} = {
1453 do with_scope_result(bcx, None,
1454 ~"compare_scope") |bcx| {
1455 match trans_opt(bcx, opt) {
1457 Result {bcx, val}) => {
1458 compare_values(bcx, test_val, val, t)
1461 Result {bcx, val}) => {
1462 compare_scalar_types(
1467 Result {val: vbegin, _},
1468 Result {bcx, val: vend}) => {
1469 let Result {bcx, val: llge} =
1470 compare_scalar_types(
1472 vbegin, t, ast::ge);
1473 let Result {bcx, val: llle} =
1474 compare_scalar_types(
1475 bcx, test_val, vend,
1477 rslt(bcx, And(bcx, llge, llle))
1482 bcx = sub_block(after_cx, ~"compare_next");
1483 CondBr(after_cx, matches, opt_cx.llbb, bcx.llbb);
1485 compare_vec_len => {
1486 let Result {bcx: after_cx, val: matches} = {
1487 do with_scope_result(bcx, None,
1488 ~"compare_vec_len_scope") |bcx| {
1489 match trans_opt(bcx, opt) {
1491 Result {bcx, val}) => {
1492 let value = compare_scalar_values(
1494 signed_int, ast::eq);
1498 Result {bcx, val: val}) => {
1499 let value = compare_scalar_values(
1501 signed_int, ast::ge);
1505 Result {val: vbegin, _},
1506 Result {bcx, val: vend}) => {
1508 compare_scalar_values(
1510 vbegin, signed_int, ast::ge);
1512 compare_scalar_values(
1513 bcx, test_val, vend,
1514 signed_int, ast::le);
1515 rslt(bcx, And(bcx, llge, llle))
1520 bcx = sub_block(after_cx, ~"compare_vec_len_next");
1521 CondBr(after_cx, matches, opt_cx.llbb, bcx.llbb);
1525 } else if kind == compare || kind == compare_vec_len {
1526 Br(bcx, else_cx.llbb);
1530 let mut unpacked = ~[];
1532 var(disr_val, repr) => {
1533 let ExtractedBlock {vals: argvals, bcx: new_bcx} =
1534 extract_variant_args(opt_cx, repr, disr_val, val);
1535 size = argvals.len();
1539 vec_len_eq(n) | vec_len_ge(n, _) => {
1540 let n = match *opt {
1541 vec_len_ge(*) => n + 1u,
1544 let slice = match *opt {
1545 vec_len_ge(_, i) => Some(i),
1548 let args = extract_vec_elems(opt_cx, pat_id, n, slice,
1550 size = args.vals.len();
1551 unpacked = /*bad*/copy args.vals;
1554 lit(_) | range(_, _) => ()
1556 let opt_ms = enter_opt(opt_cx, m, opt, col, size, val);
1557 let opt_vals = vec::append(unpacked, vals_left);
1558 compile_submatch(opt_cx, opt_ms, opt_vals, chk);
1561 // Compile the fall-through case, if any
1563 if kind == compare || kind == compare_vec_len {
1564 Br(bcx, else_cx.llbb);
1567 compile_submatch(else_cx, defaults, vals_left, chk);
1572 pub fn trans_match(bcx: block,
1573 match_expr: @ast::expr,
1574 discr_expr: @ast::expr,
1576 dest: Dest) -> block {
1577 let _icx = bcx.insn_ctxt("match::trans_match");
1578 do with_scope(bcx, match_expr.info(), ~"match") |bcx| {
1579 trans_match_inner(bcx, discr_expr, arms, dest)
1583 pub fn trans_match_inner(scope_cx: block,
1584 discr_expr: @ast::expr,
1586 dest: Dest) -> block {
1587 let _icx = scope_cx.insn_ctxt("match::trans_match_inner");
1588 let mut bcx = scope_cx;
1589 let tcx = bcx.tcx();
1591 let discr_datum = unpack_datum!(bcx, {
1592 expr::trans_to_datum(bcx, discr_expr)
1594 if bcx.unreachable {
1598 let mut arm_datas = ~[], matches = ~[];
1599 for vec::each(arms) |arm| {
1600 let body = scope_block(bcx, arm.body.info(), ~"case_body");
1602 // Create the bindings map, which is a mapping from each binding name
1603 // to an alloca() that will be the value for that local variable.
1604 // Note that we use the names because each binding will have many ids
1605 // from the various alternatives.
1606 let bindings_map = HashMap();
1607 do pat_bindings(tcx.def_map, arm.pats[0]) |bm, p_id, _s, path| {
1608 let ident = path_to_ident(path);
1609 let variable_ty = node_id_type(bcx, p_id);
1610 let llvariable_ty = type_of::type_of(bcx.ccx(), variable_ty);
1612 let llmatch, trmode;
1614 ast::bind_by_copy | ast::bind_infer => {
1615 // in this case, the final type of the variable will be T,
1616 // but during matching we need to store a *T as explained
1619 scope_cx.ccx().maps.moves_map.contains_key(&p_id);
1620 llmatch = alloca(bcx, T_ptr(llvariable_ty));
1621 trmode = TrByValue(is_move, alloca(bcx, llvariable_ty));
1623 ast::bind_by_ref(_) => {
1624 llmatch = alloca(bcx, llvariable_ty);
1628 bindings_map.insert(ident, BindingInfo {
1629 llmatch: llmatch, trmode: trmode,
1630 id: p_id, ty: variable_ty
1634 let arm_data = @ArmData {bodycx: body,
1636 bindings_map: bindings_map};
1637 arm_datas.push(arm_data);
1638 for vec::each(arm.pats) |p| {
1639 matches.push(@Match {pats: ~[*p], data: arm_data});
1643 let t = node_id_type(bcx, discr_expr.id);
1645 if ty::type_is_empty(tcx, t) {
1646 // Special case for empty types
1647 let fail_cx = @mut None;
1648 let f: mk_fail = || mk_fail(scope_cx, discr_expr.span,
1649 @~"scrutinizing value that can't exist", fail_cx);
1655 let lldiscr = discr_datum.to_ref_llval(bcx);
1656 compile_submatch(bcx, matches, ~[lldiscr], chk);
1658 let mut arm_cxs = ~[];
1659 for arm_datas.each |arm_data| {
1660 let mut bcx = arm_data.bodycx;
1662 // If this arm has a guard, then the various by-value bindings have
1663 // already been copied into their homes. If not, we do it here. This
1664 // is just to reduce code space. See extensive comment at the start
1665 // of the file for more details.
1666 if arm_data.arm.guard.is_none() {
1667 bcx = store_non_ref_bindings(bcx, *arm_data, None);
1670 // insert bindings into the lllocals map and add cleanups
1671 bcx = insert_lllocals(bcx, *arm_data, true);
1673 bcx = controlflow::trans_block(bcx, &arm_data.arm.body, dest);
1674 bcx = trans_block_cleanups(bcx, block_cleanups(arm_data.bodycx));
1678 bcx = controlflow::join_blocks(scope_cx, arm_cxs);
1681 fn mk_fail(bcx: block, sp: span, msg: @~str,
1682 finished: @mut Option<BasicBlockRef>) -> BasicBlockRef {
1683 match *finished { Some(bb) => return bb, _ => () }
1684 let fail_cx = sub_block(bcx, ~"case_fallthrough");
1685 controlflow::trans_fail(fail_cx, Some(sp), msg);
1686 *finished = Some(fail_cx.llbb);
1687 return fail_cx.llbb;
1691 pub enum IrrefutablePatternBindingMode {
1692 // Stores the association between node ID and LLVM value in `lllocals`.
1694 // Stores the association between node ID and LLVM value in `llargs`.
1698 // Not match-related, but similar to the pattern-munging code above
1699 pub fn bind_irrefutable_pat(bcx: block,
1703 binding_mode: IrrefutablePatternBindingMode)
1705 let _icx = bcx.insn_ctxt("match::bind_irrefutable_pat");
1706 let ccx = *bcx.fcx.ccx;
1709 // Necessary since bind_irrefutable_pat is called outside trans_match
1711 ast::pat_ident(_, _, ref inner) => {
1712 if pat_is_variant_or_struct(bcx.tcx().def_map, pat) {
1717 let binding_ty = node_id_type(bcx, pat.id);
1718 let datum = Datum {val: val, ty: binding_ty,
1719 mode: ByRef, source: RevokeClean};
1720 let scratch = scratch_datum(bcx, binding_ty, false);
1721 datum.copy_to_datum(bcx, INIT, scratch);
1722 match binding_mode {
1724 bcx.fcx.lllocals.insert(pat.id,
1725 local_mem(scratch.val));
1728 bcx.fcx.llargs.insert(pat.id,
1729 local_mem(scratch.val));
1732 add_clean(bcx, scratch.val, binding_ty);
1734 match binding_mode {
1736 bcx.fcx.lllocals.insert(pat.id, local_mem(val));
1739 bcx.fcx.llargs.insert(pat.id, local_mem(val));
1744 for inner.each |inner_pat| {
1745 bcx = bind_irrefutable_pat(
1746 bcx, *inner_pat, val, true, binding_mode);
1749 ast::pat_enum(_, ref sub_pats) => {
1750 match bcx.tcx().def_map.find(&pat.id) {
1751 Some(ast::def_variant(enum_id, var_id)) => {
1752 let repr = adt::represent_node(bcx, pat.id);
1753 let vinfo = ty::enum_variant_with_id(ccx.tcx,
1756 let args = extract_variant_args(bcx,
1760 for sub_pats.each |sub_pat| {
1761 for vec::eachi(args.vals) |i, argval| {
1762 bcx = bind_irrefutable_pat(bcx,
1770 Some(ast::def_struct(*)) => {
1773 // This is a unit-like struct. Nothing to do here.
1775 Some(ref elems) => {
1776 // This is the tuple struct case.
1777 let repr = adt::represent_node(bcx, pat.id);
1778 for elems.eachi |i, elem| {
1779 let fldptr = adt::trans_field_ptr(bcx, repr,
1781 bcx = bind_irrefutable_pat(bcx,
1790 Some(ast::def_const(*)) => {
1791 bcx = bind_irrefutable_pat(bcx, pat, val, make_copy, binding_mode);
1794 // Nothing to do here.
1798 ast::pat_struct(_, ref fields, _) => {
1799 let tcx = bcx.tcx();
1800 let pat_ty = node_id_type(bcx, pat.id);
1801 let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
1802 do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
1803 for fields.each |f| {
1804 let ix = ty::field_idx_strict(tcx, f.ident, field_tys);
1805 let fldptr = adt::trans_field_ptr(bcx, pat_repr, val,
1807 bcx = bind_irrefutable_pat(bcx,
1815 ast::pat_tup(ref elems) => {
1816 let repr = adt::represent_node(bcx, pat.id);
1817 for elems.eachi |i, elem| {
1818 let fldptr = adt::trans_field_ptr(bcx, repr, val, 0, i);
1819 bcx = bind_irrefutable_pat(bcx,
1826 ast::pat_box(inner) | ast::pat_uniq(inner) => {
1827 let llbox = Load(bcx, val);
1828 let unboxed = GEPi(bcx, llbox, [0u, abi::box_field_body]);
1829 bcx = bind_irrefutable_pat(bcx,
1835 ast::pat_region(inner) => {
1836 let loaded_val = Load(bcx, val);
1837 bcx = bind_irrefutable_pat(bcx,
1843 ast::pat_wild | ast::pat_lit(_) | ast::pat_range(_, _) |
1844 ast::pat_vec(*) => ()
1852 // indent-tabs-mode: nil
1853 // c-basic-offset: 4
1854 // buffer-file-coding-system: utf-8-unix