simplify token and span structures

src/asm/defs/ruledef_map.rs

@@ -117,7 +117,7 @@ impl RuledefMap
 
             if token.kind.is_allowed_pattern_token()
             {
-                for c in token.text().chars()
+                for c in walker.get_span_excerpt(token.span).chars()
                 {
                     if prefix_index >= MAX_PREFIX_SIZE
                     {

src/asm/matcher/mod.rs

@@ -347,7 +347,7 @@ pub fn match_instr(
     let mut walker = syntax::Walker::new(
         src,
         span.file_handle,
-        span.location().unwrap().0 as usize);
+        span.location().unwrap().0);
 
     if opts.optimize_instruction_matching
     {

src/asm/parser/directive.rs

@@ -10,7 +10,7 @@ pub fn parse(
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
     let header_span = tk_hash.span.join(tk_name.span);
 
-    let name = tk_name.excerpt.as_ref().unwrap().to_ascii_lowercase();
+    let name = walker.get_span_excerpt(tk_name.span).to_ascii_lowercase();
 
     if name.chars().next() == Some('d')
     {

src/asm/parser/directive_bank.rs

@@ -19,7 +19,7 @@ pub fn parse(
     -> Result<AstDirectiveBank, ()>
 {
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.clone().unwrap();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
     let name_span = tk_name.span;
 
     walker.expect_linebreak(report)?;

src/asm/parser/directive_bankdef.rs

@@ -27,7 +27,7 @@ pub fn parse(
     -> Result<AstDirectiveBankdef, ()>
 {
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.clone().unwrap();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
     let name_span = tk_name.span;
 
     walker.expect(report, syntax::TokenKind::BraceOpen)?;

src/asm/parser/directive_const.rs

@@ -12,7 +12,7 @@ pub fn parse(
     if let Some(_) = walker.maybe_expect(syntax::TokenKind::ParenOpen)
     {
         let tk_attrb = walker.expect(report, syntax::TokenKind::Identifier)?;
-        let attrb = tk_attrb.excerpt.as_ref().unwrap();
+        let attrb = walker.get_span_excerpt(tk_attrb.span);
 
         match attrb.as_ref()
         {
@@ -41,7 +41,7 @@ pub fn parse(
     }
 
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.clone().unwrap();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
     decl_span = decl_span.join(tk_name.span);
 
 

src/asm/parser/directive_fn.rs

@@ -28,7 +28,7 @@ pub fn parse(
     -> Result<AstDirectiveFn, ()>
 {
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.clone().unwrap();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
 
     walker.expect(report, syntax::TokenKind::ParenOpen)?;
 
@@ -38,7 +38,7 @@ pub fn parse(
         !walker.next_useful_is(0, syntax::TokenKind::ParenClose)
     {
         let tk_param_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-        let param_name = tk_param_name.excerpt.clone().unwrap();
+        let param_name = walker.get_span_excerpt(tk_param_name.span).to_string();
 
         params.push(AstFnParameter {
             name: param_name,

src/asm/parser/directive_if.rs

@@ -61,10 +61,8 @@ fn parse_else_blocks(
         return Ok(None);
     }
 
-    let directive_name = walker
-        .next_nth_useful_token(1)
-        .excerpt
-        .unwrap();
+    let token = walker.next_nth_useful_token(1);
+    let directive_name = walker.get_span_excerpt(token.span);
 
     if directive_name == "else"
     {

src/asm/parser/directive_include.rs

@@ -21,7 +21,7 @@ pub fn parse(
     let filename = syntax::excerpt_as_string_contents(
         report,
         tk_filename.span,
-        tk_filename.excerpt.as_ref().unwrap())?;
+        walker.get_span_excerpt(tk_filename.span))?;
 
     walker.expect_linebreak(report)?;
 

src/asm/parser/directive_ruledef.rs

@@ -61,7 +61,7 @@ pub fn parse(
     -> Result<AstDirectiveRuledef, ()>
 {
     let tk_name = walker.maybe_expect(syntax::TokenKind::Identifier);
-    let name = tk_name.clone().map(|tk| tk.excerpt.clone().unwrap());
+    let name = tk_name.clone().map(|tk| walker.get_span_excerpt(tk.span).to_string());
     let name_span = tk_name
         .map(|tk| tk.span)
         .unwrap_or_else(|| header_span);
@@ -116,7 +116,7 @@ fn parse_rule(
         !walker.next_useful_is(0, syntax::TokenKind::HeavyArrowRight)
     {
         let tk = walker.next_token();
-        walker.skip_to_token_end(&tk);
+        walker.advance_to_token_end(&tk);
 
         pattern_span = pattern_span.join(tk.span);
 
@@ -142,7 +142,7 @@ fn parse_rule(
 
         else if tk.kind.is_allowed_pattern_token()
         {
-            for c in tk.text().chars()
+            for c in walker.get_span_excerpt(tk.span).chars()
             {
                 pattern.push(AstRulePatternPart::Exact(c.to_ascii_lowercase()));
             }
@@ -192,15 +192,15 @@ fn parse_rule_parameter(
     -> Result<AstRuleParameter, ()>
 {
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.as_ref().unwrap().clone();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
     let name_span = tk_name.span;
 
     let (typ, type_span) = {
         if walker.maybe_expect(syntax::TokenKind::Colon).is_some()
         {
             let tk_typename = walker.expect(report, syntax::TokenKind::Identifier)?;
-            let typename = tk_typename.excerpt.as_ref().unwrap().clone();
-            let typ = interpret_typename(&typename);
+            let typename = walker.get_span_excerpt(tk_typename.span);
+            let typ = interpret_typename(typename);
             (typ, tk_typename.span)
         }
         else

src/asm/parser/fields.rs

@@ -33,7 +33,7 @@ pub fn parse(
             walker.maybe_expect(syntax::TokenKind::Hash).is_some();
 
         let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-        let name = tk_name.excerpt.as_ref().unwrap().clone();
+        let name = walker.get_span_excerpt(tk_name.span).to_string();
 
         if let Some(_) = fields.fields.iter().find(|f| f.name == name)
         {

src/asm/parser/symbol.rs

@@ -44,7 +44,7 @@ pub fn parse(
     }
 
     let tk_name = walker.expect(report, syntax::TokenKind::Identifier)?;
-    let name = tk_name.excerpt.clone().unwrap();
+    let name = walker.get_span_excerpt(tk_name.span).to_string();
     decl_span = decl_span.join(tk_name.span);
 
 

src/asm/resolver/eval_asm.rs

@@ -167,7 +167,7 @@ fn parse_substitutions<'excerpt>(
     let mut walker = syntax::Walker::new(
         excerpt,
         span.file_handle,
-        span.location().unwrap().0 as usize);
+        span.location().unwrap().0);
 
     while !walker.is_over()
     {
@@ -182,7 +182,7 @@ fn parse_substitutions<'excerpt>(
                 report,
                 syntax::TokenKind::Identifier)?;
 
-            let name = tk_name.clone().excerpt.unwrap();
+            let name = walker.get_span_excerpt(tk_name.span).to_string();
             let span = tk_name.span;
 
             walker.expect(
@@ -200,7 +200,7 @@ fn parse_substitutions<'excerpt>(
         }
         else
         {
-            walker.skip_to_token_end(&walker.next_token());
+            walker.advance_to_token_end(&walker.next_token());
         }
     }
 

src/diagn/mod.rs

@@ -1,8 +1,5 @@
 mod span;
-pub use self::span::{
-    Span,
-    SpanIndex,
-};
+pub use self::span::Span;
 
 mod report;
 pub use self::report::{

src/diagn/span.rs

@@ -1,25 +1,23 @@
 use crate::*;
 
 
-pub type SpanIndex = u32;
-
-
 #[derive(Copy, Clone, Hash, Eq)]
 pub struct Span
 {
 	pub file_handle: util::FileServerHandle,
 
-	/// Represents byte indices (not UTF-8 char indices)
-	location: (SpanIndex, SpanIndex),
+	/// Represents byte indices into the file contents
+	/// (as opposed to UTF-8 char boundaries).
+	location: (usize, usize),
 }
 
 
 impl Span
 {
 	pub fn new(
 		file_handle: util::FileServerHandle,
-		start: SpanIndex,
-		end: SpanIndex)
+		start: usize,
+		end: usize)
 		-> Span
 	{
 		Span {
@@ -33,14 +31,14 @@ impl Span
 	{
 		Span {
 			file_handle: 0,
-			location: (SpanIndex::MAX, SpanIndex::MAX),
+			location: (usize::MAX, usize::MAX),
 		}
 	}
 
 
-	pub fn location(&self) -> Option<(SpanIndex, SpanIndex)>
+	pub fn location(&self) -> Option<(usize, usize)>
 	{
-		if self.location.0 == SpanIndex::MAX
+		if self.location.0 == usize::MAX
 		{
 			return None;
 		}
@@ -51,18 +49,18 @@ impl Span
 
 	pub fn length(&self) -> usize
 	{
-		if self.location.0 == SpanIndex::MAX
+		if self.location.0 == usize::MAX
 		{
 			return 0;
 		}
 
-		(self.location.1 - self.location.0) as usize
+		self.location.1 - self.location.0
 	}
 
 
 	pub fn before(&self) -> Span
 	{
-		if self.location.0 == SpanIndex::MAX
+		if self.location.0 == usize::MAX
 		{
 			*self
 		}
@@ -81,7 +79,7 @@ impl Span
 
 	pub fn after(&self) -> Span
 	{
-		if self.location.0 == SpanIndex::MAX
+		if self.location.0 == usize::MAX
 		{
 			*self
 		}
@@ -102,8 +100,8 @@ impl Span
 	{
 		match (self.location, other.location)
 		{
-			(_, (SpanIndex::MAX, _)) => *self,
-			((SpanIndex::MAX, _), _) => other,
+			(_, (usize::MAX, _)) => *self,
+			((usize::MAX, _), _) => other,
 			(self_loc, other_loc) =>
 			{
 				assert!(
@@ -145,12 +143,12 @@ impl std::fmt::Debug for Span
         f.write_str("Span(")?;
 		write!(f, "file#{:?}", &self.file_handle)?;
 
-		if self.location.0 != SpanIndex::MAX
+		if self.location.0 != usize::MAX
 		{
 			f.write_str("[")?;
-			<SpanIndex as std::fmt::Debug>::fmt(&self.location.0, f)?;
+			<usize as std::fmt::Debug>::fmt(&self.location.0, f)?;
 			f.write_str("..")?;
-			<SpanIndex as std::fmt::Debug>::fmt(&self.location.1, f)?;
+			<usize as std::fmt::Debug>::fmt(&self.location.1, f)?;
 			f.write_str("]")?;
 		}
 

src/expr/parser.rs

@@ -522,7 +522,7 @@ impl<'a, 'src> ExpressionParser<'a, 'src>
 		loop
 		{
 			let tk_name = self.walker.expect(self.report, syntax::TokenKind::Identifier)?;
-			let name = tk_name.excerpt.clone().unwrap();
+			let name = self.walker.get_span_excerpt(tk_name.span).to_string();
 			hierarchy.push(name);
 			span = span.join(tk_name.span);
 
@@ -544,12 +544,12 @@ impl<'a, 'src> ExpressionParser<'a, 'src>
 	fn parse_number(&mut self) -> Result<expr::Expr, ()>
 	{
 		let tk_number = self.walker.expect(self.report, syntax::TokenKind::Number)?;
-		let number = tk_number.excerpt.clone().unwrap();
+		let number = self.walker.get_span_excerpt(tk_number.span);
 
 		let bigint = syntax::excerpt_as_bigint(
 			Some(self.report),
 			tk_number.span,
-			&number)?;
+			number)?;
 
 		let expr = expr::Expr::Literal(
 			tk_number.span,
@@ -594,7 +594,7 @@ impl<'a, 'src> ExpressionParser<'a, 'src>
 		let string = syntax::excerpt_as_string_contents(
 			self.report,
 			tk_str.span,
-			tk_str.excerpt.as_ref().unwrap())?;
+			self.walker.get_span_excerpt(tk_str.span))?;
 
 		let expr = expr::Expr::Literal(
 			tk_str.span,