Fix defining predeclared items

src/ast/declarations/function.rs

@@ -6,7 +6,8 @@ use derive_more::From;
 use crate::{
     ast::{Annotation, Expression, Statement, TypeReference},
     syntax::{
-        error::ParseError, Context, Identifier, Keyword, Lexer, OperatorKind, Parse, Ranged, StartsHere, StringWithOffset, Token
+        error::ParseError, Context, Identifier, Keyword, Lexer, OperatorKind, Parse, Ranged,
+        StartsHere, StringWithOffset, Token,
     },
 };
 
@@ -163,6 +164,19 @@ pub struct FunctionDeclaration {
     pub annotations: Vec<Annotation>,
 }
 
+impl Ranged for FunctionDeclaration {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.body
+            .last()
+            // FIXME: respect return_type, name_parts, generic_parameters
+            .map_or_else(|| self.keyword.end(), |s| s.end())
+    }
+}
+
 impl StartsHere for FunctionDeclaration {
     /// Check that function declaration may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {

src/ast/declarations/mod.rs

@@ -1,4 +1,6 @@
 mod function;
+use std::ops::Range;
+
 pub use function::*;
 
 mod types;
@@ -15,7 +17,7 @@ use ast_derive::AST;
 
 use crate::syntax::{
     error::{MissingDeclaration, ParseError},
-    Context, Lexer, Parse, StartsHere, Token,
+    Context, Lexer, Parse, Ranged, StartsHere, Token,
 };
 
 use derive_more::From;
@@ -29,6 +31,18 @@ pub enum Declaration {
     Trait(TraitDeclaration),
 }
 
+impl Ranged for Declaration {
+    fn range(&self) -> Range<usize> {
+        use Declaration::*;
+        match self {
+            Variable(s) => s.range(),
+            Type(s) => s.range(),
+            Function(s) => s.range(),
+            Trait(s) => s.range(),
+        }
+    }
+}
+
 impl StartsHere for Declaration {
     /// Check literal may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {

src/ast/declarations/trait.rs

@@ -2,7 +2,7 @@ extern crate ast_derive;
 use ast_derive::AST;
 
 use crate::syntax::{
-    error::ParseError, Context, Identifier, Keyword, Lexer, Parse, StartsHere, Token
+    error::ParseError, Context, Identifier, Keyword, Lexer, Parse, Ranged, StartsHere, Token,
 };
 
 use super::FunctionDeclaration;
@@ -18,6 +18,18 @@ pub struct TraitDeclaration {
     pub functions: Vec<FunctionDeclaration>,
 }
 
+impl Ranged for TraitDeclaration {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.functions
+            .last()
+            .map_or_else(|| self.name.end(), |s| s.end())
+    }
+}
+
 impl StartsHere for TraitDeclaration {
     /// Check that type declaration may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {
@@ -38,6 +50,10 @@ impl Parse for TraitDeclaration {
 
         let functions = context.parse_block(FunctionDeclaration::parse)?;
 
-        Ok(TraitDeclaration { keyword, name, functions })
+        Ok(TraitDeclaration {
+            keyword,
+            name,
+            functions,
+        })
     }
 }

src/ast/declarations/types.rs

@@ -4,7 +4,7 @@ use ast_derive::AST;
 use crate::{
     ast::{Annotation, TypeReference},
     syntax::{
-        error::ParseError, Context, Identifier, Keyword, Lexer, Parse, StartsHere, Token
+        error::ParseError, Context, Identifier, Keyword, Lexer, Parse, Ranged, StartsHere, Token,
     },
 };
 
@@ -17,6 +17,16 @@ pub struct Member {
     pub ty: TypeReference,
 }
 
+impl Ranged for Member {
+    fn start(&self) -> usize {
+        self.name.start()
+    }
+
+    fn end(&self) -> usize {
+        self.ty.end()
+    }
+}
+
 /// Parse single or multiple members, if they are separated by comma
 pub fn parse_members(context: &mut Context<impl Lexer>) -> Result<Vec<Member>, ParseError> {
     let names = context.parse_comma_separated(|context| context.consume_id());
@@ -77,6 +87,19 @@ pub struct TypeDeclaration {
     pub members: Vec<Member>,
 }
 
+impl Ranged for TypeDeclaration {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.members
+            .last()
+            // FIXME: respect generic parameters
+            .map_or_else(|| self.name.end(), |s| s.end())
+    }
+}
+
 impl StartsHere for TypeDeclaration {
     /// Check that type declaration may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {

src/ast/declarations/variable.rs

@@ -4,7 +4,7 @@ use ast_derive::AST;
 use crate::ast::{Expression, TypeReference};
 use crate::mutability::{Mutability, Mutable};
 use crate::syntax::error::{MissingVariableName, ParseError};
-use crate::syntax::{Context, Identifier, Keyword, Lexer, Parse, StartsHere, Token};
+use crate::syntax::{Context, Identifier, Keyword, Lexer, Parse, Ranged, StartsHere, Token};
 
 /// Declaration of the variable
 #[derive(Debug, PartialEq, Eq, AST, Clone)]
@@ -22,6 +22,16 @@ pub struct VariableDeclaration {
     pub mutability: Mutability,
 }
 
+impl Ranged for VariableDeclaration {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.initializer.end()
+    }
+}
+
 impl Mutable for VariableDeclaration {
     fn is_mutable(&self) -> bool {
         self.mutability.is_mutable()

src/ast/statements/assignment.rs

@@ -3,7 +3,7 @@ use ast_derive::AST;
 
 use crate::ast::Expression;
 use crate::syntax::{error::ParseError, Lexer, Parse, Token};
-use crate::syntax::{Context, StartsHere};
+use crate::syntax::{Context, Ranged, StartsHere};
 
 /// AST for assignment
 #[derive(Debug, PartialEq, Eq, AST, Clone)]
@@ -14,6 +14,16 @@ pub struct Assignment {
     pub value: Expression,
 }
 
+impl Ranged for Assignment {
+    fn start(&self) -> usize {
+        self.target.start()
+    }
+
+    fn end(&self) -> usize {
+        self.value.end()
+    }
+}
+
 impl StartsHere for Assignment {
     /// Check that assignment may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {

src/ast/statements/if.rs

@@ -3,7 +3,7 @@ use ast_derive::AST;
 
 use crate::ast::Expression;
 use crate::syntax::{error::ParseError, Lexer, Parse, Token};
-use crate::syntax::{Context, Keyword, StartsHere};
+use crate::syntax::{Context, Keyword, Ranged, StartsHere};
 
 use super::Statement;
 
@@ -19,6 +19,18 @@ pub struct ElseIf {
     pub body: Vec<Statement>,
 }
 
+impl Ranged for ElseIf {
+    fn start(&self) -> usize {
+        self.else_keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.body
+            .last()
+            .map_or_else(|| self.condition.end(), |s| s.end())
+    }
+}
+
 /// AST for else block
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Else {
@@ -28,6 +40,18 @@ pub struct Else {
     pub body: Vec<Statement>,
 }
 
+impl Ranged for Else {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.body
+            .last()
+            .map_or_else(|| self.keyword.end(), |s| s.end())
+    }
+}
+
 /// AST for if-statement
 #[derive(Debug, PartialEq, Eq, AST, Clone)]
 pub struct If {
@@ -43,6 +67,24 @@ pub struct If {
     pub else_block: Option<Else>,
 }
 
+impl Ranged for If {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        if let Some(else_block) = &self.else_block {
+            else_block.end()
+        } else if let Some(else_if) = self.else_ifs.last() {
+            else_if.end()
+        } else {
+            self.body
+                .last()
+                .map_or_else(|| self.condition.end(), |s| s.end())
+        }
+    }
+}
+
 impl StartsHere for If {
     /// Check that assignment may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {
@@ -71,12 +113,17 @@ impl Parse for If {
 
                 context.lexer.consume(Token::Colon)?;
                 let body = context.parse_block(Statement::parse)?;
-                else_ifs.push(ElseIf { else_keyword, if_keyword, condition, body });
+                else_ifs.push(ElseIf {
+                    else_keyword,
+                    if_keyword,
+                    condition,
+                    body,
+                });
             } else {
                 context.lexer.consume(Token::Colon)?;
                 else_block = Some(Else {
                     keyword: else_keyword,
-                    body: context.parse_block(Statement::parse)?
+                    body: context.parse_block(Statement::parse)?,
                 });
                 break;
             }

src/ast/statements/loop.rs

@@ -4,7 +4,7 @@ use ast_derive::AST;
 
 use crate::ast::Statement;
 use crate::syntax::{error::ParseError, Lexer, Parse, Token};
-use crate::syntax::{Context, Keyword, StartsHere};
+use crate::syntax::{Context, Keyword, Ranged, StartsHere};
 
 /// AST for infinite loop
 #[derive(Debug, PartialEq, Eq, AST, Clone)]
@@ -14,6 +14,18 @@ pub struct Loop {
     pub body: Vec<Statement>,
 }
 
+impl Ranged for Loop {
+    fn start(&self) -> usize {
+        self.keyword.start()
+    }
+
+    fn end(&self) -> usize {
+        self.body
+            .last()
+            .map_or_else(|| self.keyword.end(), |s| s.end())
+    }
+}
+
 impl StartsHere for Loop {
     /// Check that loop starts at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {

src/ast/statements/mod.rs

@@ -1,4 +1,6 @@
 mod assignment;
+use std::ops::Range;
+
 pub use assignment::*;
 
 mod ret;
@@ -22,7 +24,7 @@ use ast_derive::AST;
 use crate::ast::{Declaration, Expression};
 use crate::syntax::error::MissingStatement;
 use crate::syntax::{error::ParseError, Lexer, Parse, Token};
-use crate::syntax::{Context, StartsHere};
+use crate::syntax::{Context, Ranged, StartsHere};
 
 use derive_more::From;
 
@@ -41,6 +43,22 @@ pub enum Statement {
     Use(Use),
 }
 
+impl Ranged for Statement {
+    fn range(&self) -> Range<usize> {
+        use Statement::*;
+        match self {
+            Declaration(s) => s.range(),
+            Expression(s) => s.range(),
+            Assignment(s) => s.range(),
+            Return(s) => s.range(),
+            If(s) => s.range(),
+            Loop(s) => s.range(),
+            While(s) => s.range(),
+            Use(s) => s.range(),
+        }
+    }
+}
+
 impl StartsHere for Statement {
     /// Check that statement may start at current lexer position
     fn starts_here(context: &mut Context<impl Lexer>) -> bool {