@@ -44,8 +44,8 @@ use crate::{
4444 FormatPlaceholder , FormatSign , FormatTrait ,
4545 } ,
4646 Array , Binding , BindingAnnotation , BindingId , BindingProblems , CaptureBy , ClosureKind ,
47- Expr , ExprId , Item , Label , LabelId , Literal , LiteralOrConst , MatchArm , Movability ,
48- OffsetOf , Pat , PatId , RecordFieldPat , RecordLitField , Statement ,
47+ Expr , ExprId , Item , Label , LabelId , Literal , MatchArm , Movability , OffsetOf , Pat , PatId ,
48+ RecordFieldPat , RecordLitField , Statement ,
4949 } ,
5050 item_scope:: BuiltinShadowMode ,
5151 lang_item:: LangItem ,
@@ -1784,23 +1784,33 @@ impl ExprCollector<'_> {
17841784 self . collect_macro_call ( call, macro_ptr, true , |this, expanded_pat| {
17851785 this. collect_pat_opt ( expanded_pat, binding_list)
17861786 } ) ;
1787- self . source_map . pat_map . insert ( src, pat) ;
1787+ self . source_map . pat_map . insert ( src, pat. into ( ) ) ;
17881788 return pat;
17891789 }
17901790 None => Pat :: Missing ,
17911791 } ,
1792- // FIXME: implement in a way that also builds source map and calculates assoc resolutions in type inference.
17931792 ast:: Pat :: RangePat ( p) => {
1794- let mut range_part_lower = |p : Option < ast:: Pat > | {
1795- p. and_then ( |it| match & it {
1796- ast:: Pat :: LiteralPat ( it) => {
1797- Some ( Box :: new ( LiteralOrConst :: Literal ( pat_literal_to_hir ( it) ?. 0 ) ) )
1793+ let mut range_part_lower = |p : Option < ast:: Pat > | -> Option < ExprId > {
1794+ p. and_then ( |it| {
1795+ let ptr = PatPtr :: new ( & it) ;
1796+ match & it {
1797+ ast:: Pat :: LiteralPat ( it) => Some ( self . alloc_expr_from_pat (
1798+ Expr :: Literal ( pat_literal_to_hir ( it) ?. 0 ) ,
1799+ ptr,
1800+ ) ) ,
1801+ ast:: Pat :: IdentPat ( ident) if ident. is_simple_ident ( ) => ident
1802+ . name ( )
1803+ . map ( |name| name. as_name ( ) )
1804+ . map ( Path :: from)
1805+ . map ( |path| self . alloc_expr_from_pat ( Expr :: Path ( path) , ptr) ) ,
1806+ ast:: Pat :: PathPat ( p) => p
1807+ . path ( )
1808+ . and_then ( |path| self . parse_path ( path) )
1809+ . map ( |parsed| self . alloc_expr_from_pat ( Expr :: Path ( parsed) , ptr) ) ,
1810+ // We only need to handle literal, ident (if bare) and path patterns here,
1811+ // as any other pattern as a range pattern operand is semantically invalid.
1812+ _ => None ,
17981813 }
1799- pat @ ( ast:: Pat :: IdentPat ( _) | ast:: Pat :: PathPat ( _) ) => {
1800- let subpat = self . collect_pat ( pat. clone ( ) , binding_list) ;
1801- Some ( Box :: new ( LiteralOrConst :: Const ( subpat) ) )
1802- }
1803- _ => None ,
18041814 } )
18051815 } ;
18061816 let start = range_part_lower ( p. start ( ) ) ;
@@ -1863,7 +1873,7 @@ impl ExprCollector<'_> {
18631873 }
18641874 } ) ;
18651875 if let Some ( pat) = pat. left ( ) {
1866- self . source_map . pat_map . insert ( src, pat) ;
1876+ self . source_map . pat_map . insert ( src, pat. into ( ) ) ;
18671877 }
18681878 pat
18691879 }
@@ -2490,7 +2500,7 @@ impl ExprCollector<'_> {
24902500 fn alloc_expr ( & mut self , expr : Expr , ptr : ExprPtr ) -> ExprId {
24912501 let src = self . expander . in_file ( ptr) ;
24922502 let id = self . store . exprs . alloc ( expr) ;
2493- self . source_map . expr_map_back . insert ( id, src) ;
2503+ self . source_map . expr_map_back . insert ( id, src. map ( AstPtr :: wrap_left ) ) ;
24942504 self . source_map . expr_map . insert ( src, id. into ( ) ) ;
24952505 id
24962506 }
@@ -2502,7 +2512,7 @@ impl ExprCollector<'_> {
25022512 fn alloc_expr_desugared_with_ptr ( & mut self , expr : Expr , ptr : ExprPtr ) -> ExprId {
25032513 let src = self . expander . in_file ( ptr) ;
25042514 let id = self . store . exprs . alloc ( expr) ;
2505- self . source_map . expr_map_back . insert ( id, src) ;
2515+ self . source_map . expr_map_back . insert ( id, src. map ( AstPtr :: wrap_left ) ) ;
25062516 // We intentionally don't fill this as it could overwrite a non-desugared entry
25072517 // self.source_map.expr_map.insert(src, id);
25082518 id
@@ -2526,11 +2536,20 @@ impl ExprCollector<'_> {
25262536 self . source_map . pat_map_back . insert ( id, src. map ( AstPtr :: wrap_left) ) ;
25272537 id
25282538 }
2539+
2540+ fn alloc_expr_from_pat ( & mut self , expr : Expr , ptr : PatPtr ) -> ExprId {
2541+ let src = self . expander . in_file ( ptr) ;
2542+ let id = self . store . exprs . alloc ( expr) ;
2543+ self . source_map . pat_map . insert ( src, id. into ( ) ) ;
2544+ self . source_map . expr_map_back . insert ( id, src. map ( AstPtr :: wrap_right) ) ;
2545+ id
2546+ }
2547+
25292548 fn alloc_pat ( & mut self , pat : Pat , ptr : PatPtr ) -> PatId {
25302549 let src = self . expander . in_file ( ptr) ;
25312550 let id = self . store . pats . alloc ( pat) ;
25322551 self . source_map . pat_map_back . insert ( id, src. map ( AstPtr :: wrap_right) ) ;
2533- self . source_map . pat_map . insert ( src, id) ;
2552+ self . source_map . pat_map . insert ( src, id. into ( ) ) ;
25342553 id
25352554 }
25362555 // FIXME: desugared pats don't have ptr, that's wrong and should be fixed somehow.
0 commit comments