if let Some(filename) = &self.write_tokens_to {

            let mut writer = TokenWriter::new();

            let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();

            writer.write(&mut file, &self.modules);

        }

    // Points to an element in the `TokenBuffer.ranges` variable.

    stack_idx: usize,

            stack_idx: 0

        debug_assert!(target.ranges.is_empty());

        // Set up for tokenization by pushing the first range onto the stack.

        // This range may get transformed into the appropriate range kind later,

        // see `push_range` and `pop_range`.

        self.stack_idx = 0;

        target.ranges.push(TokenRange{

            parent_idx: NO_RELATION,

            range_kind: TokenRangeKind::Module,

            curly_depth: 0,

            start: 0,

            end: 0,

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

            next_sibling_idx: NO_RELATION,

        });

                    self.push_range(target, TokenRangeKind::Definition, token_index);

                    self.push_range(target, TokenRangeKind::Import, token_index);

                    self.push_range(target, TokenRangeKind::Pragma, token_index);

                let range = &target.ranges[self.stack_idx];

                if range.range_kind == TokenRangeKind::Pragma {

                    self.pop_range(target, target.tokens.len() as u32);

                }

                        let range = &target.ranges[self.stack_idx];

                        if range.range_kind == TokenRangeKind::Definition && range.curly_depth == self.curly_stack.len() as u32 {

                            self.pop_range(target, target.tokens.len() as u32);

                        }

                        // Exit early if we have more closing curly braces than

                        // opening curly braces

                    } else if token == TokenKind::SemiColon {

                        // Check if this marks the end of an import

                        let range = &target.ranges[self.stack_idx];

                        if range.range_kind == TokenRangeKind::Import {

                            self.pop_range(target, target.tokens.len() as u32);

                        }

        // Ranges that did not depend on curly braces may have missing tokens.

        // So close all of the active tokens

        while self.stack_idx != 0 {

            self.pop_range(target, target.tokens.len() as u32);

        }

        // And finally, we may have a token range at the end that doesn't belong

        // to a range yet, so insert a "code" range if this is the case.

        debug_assert_eq!(self.stack_idx, 0);

        let last_registered_idx = target.ranges[0].end;

        let last_token_idx = target.tokens.len() as u32;

        if last_registered_idx != last_token_idx {

            self.add_code_range(target, 0, last_registered_idx, last_token_idx, NO_RELATION);

        }

    fn add_code_range(

        &mut self, target: &mut TokenBuffer, parent_idx: i32,

        code_start_idx: u32, code_end_idx: u32, next_sibling_idx: i32

    ) {

        let new_range_idx = target.ranges.len() as i32;

        let parent_range = &mut target.ranges[parent_idx as usize];

        debug_assert_ne!(parent_range.end, code_end_idx, "called push_code_range without a need to do so");

        let sibling_idx = parent_range.last_child_idx;

        parent_range.last_child_idx = new_range_idx;

        parent_range.end = code_end_idx;

        parent_range.num_child_ranges += 1;

        let curly_depth = self.curly_stack.len() as u32;

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind: TokenRangeKind::Code,

            curly_depth,

            start: code_start_idx,

            end: code_end_idx,

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

            next_sibling_idx,

        });

        // Fix up the sibling indices

        if sibling_idx != NO_RELATION {

            let sibling_range = &mut target.ranges[sibling_idx as usize];

            sibling_range.next_sibling_idx = new_range_idx;

        }

    }

    fn push_range(&mut self, target: &mut TokenBuffer, range_kind: TokenRangeKind, first_token_idx: u32) {

        let new_range_idx = target.ranges.len() as i32;

        let parent_idx = self.stack_idx as i32;

        let parent_range = &mut target.ranges[self.stack_idx];

        if parent_range.first_child_idx == NO_RELATION {

            parent_range.first_child_idx = new_range_idx;

        }

        let last_registered_idx = parent_range.end;

        if last_registered_idx != first_token_idx {

            self.add_code_range(target, parent_idx, last_registered_idx, first_token_idx, new_range_idx + 1);

        }

        // Push the new range

        self.stack_idx = target.ranges.len();

        let curly_depth = self.curly_stack.len() as u32;

        target.ranges.push(TokenRange{

            parent_idx,

            range_kind,

            curly_depth,

            start: first_token_idx,

            end: first_token_idx, // modified when popped

            num_child_ranges: 0,

            first_child_idx: NO_RELATION,

            last_child_idx: NO_RELATION,

            next_sibling_idx: NO_RELATION

        })

    }

    fn pop_range(&mut self, target: &mut TokenBuffer, end_token_idx: u32) {

        let popped_idx = self.stack_idx as i32;

        let popped_range = &mut target.ranges[self.stack_idx];

        debug_assert!(self.stack_idx != 0, "attempting to pop top-level range");

        // Fix up the current range before going back to parent

        popped_range.end = end_token_idx;

        debug_assert_ne!(popped_range.start, end_token_idx);

        // Go back to parent and fix up its child pointers, but remember the

        // last child, so we can link it to the newly popped range.

        self.stack_idx = popped_range.parent_idx as usize;

        let parent = &mut target.ranges[self.stack_idx];

        if parent.first_child_idx == NO_RELATION {

            parent.first_child_idx = popped_idx;

        }

        let prev_sibling_idx = parent.last_child_idx;

        parent.last_child_idx = popped_idx;

        parent.end = end_token_idx;

        parent.num_child_ranges += 1;

        // Fix up the sibling (if it exists)

        if prev_sibling_idx != NO_RELATION {

            let sibling = &mut target.ranges[prev_sibling_idx as usize];

            sibling.next_sibling_idx = popped_idx;

        }

    }

/// The kind of token ranges that are specially parsed by the tokenizer.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

pub enum TokenRangeKind {

    Module,

    Pragma,

    Import,

    Definition,

    Code,

}

pub const NO_RELATION: i32 = -1;

pub const NO_SIBLING: i32 = NO_RELATION;

/// A range of tokens with a specific meaning. Such a range is part of a tree

/// where each parent tree envelops all of its children.

#[derive(Debug)]

pub struct TokenRange {

    // Index of parent in `TokenBuffer.ranges`, does not have a parent if the

    // range kind is Module, in that case the parent index is -1.

    pub parent_idx: i32,

    pub range_kind: TokenRangeKind,

    pub curly_depth: u32,

    // Offsets into `TokenBuffer.ranges`: the tokens belonging to this range.

    pub start: u32,             // first token (inclusive index)

    pub end: u32,               // last token (exclusive index)

    // Child ranges

    pub num_child_ranges: u32,  // Number of subranges

    pub first_child_idx: i32,   // First subrange (or -1 if no subranges)

    pub last_child_idx: i32,    // Last subrange (or -1 if no subranges)

    pub next_sibling_idx: i32,  // Next subrange (or -1 if no next subrange)

}

    pub ranges: Vec<TokenRange>,

            ranges: Vec::new()

use std::fmt::Write;

use crate::protocol::tokens::{Token, TokenKind, TokenRange};

        let mut range_index = -1;

        if !module.tokens.ranges.is_empty() {

            range_index = 0;

        }

        while range_index >= 0 {

            range_index = self.write_token_range(

                &module.source, &module.tokens.tokens, &module.tokens.ranges, range_index, 1

            );

    }

    /// Writes a single token range. Recurses if there are any child ranges.

    /// Returns the next token range index to iterate over (or a negative

    /// number, if there are no more sibling ranges).

    fn write_token_range(&mut self, source: &InputSource, tokens: &[Token], ranges: &[TokenRange], range_index: i32, indent: u32) -> i32 {

        // Write range kind

        let range = &ranges[range_index as usize];

        self.write_dashed_indent(indent);

        writeln!(self.buffer, "Range: {:?}", range.range_kind);

        // Write tokens/lines it spans

        let first_token_pos = tokens[range.start as usize].pos;

        let last_token_pos = if (range.end as usize) < tokens.len() {

            tokens[range.end as usize].pos

        } else {

            tokens.last().unwrap().pos

        };

        let first_source_col = source.get_column(first_token_pos);

        let last_source_col = source.get_column(last_token_pos);

        self.write_indent(indent);

        writeln!(

            self.buffer, "Source: token {} to {}, file {}:{}:{} to {}:{}",

            range.start, range.end, source.filename,

            first_token_pos.line, first_source_col,

            last_token_pos.line, last_source_col

        );

        let next_sibling_index = range.next_sibling_idx;

        if range.num_child_ranges == 0 {

            // No child ranges, so dump the tokens here

            debug_assert!(range.first_child_idx < 0);

            self.write_token_array(source, tokens, range, indent);

        } else {

            // Child ranges

            debug_assert!(range.first_child_idx >= 0);

            writeln!(self.buffer, "Children: [");

            let mut range_index = range.first_child_idx;

            while range_index >= 0 {

                range_index = self.write_token_range(source, tokens, ranges, range_index, indent + 1);

            writeln!(self.buffer, "]");

        }

        // Wrote everything, return the next sibling token range

        return next_sibling_index;

    fn write_token_array(&mut self, source: &InputSource, tokens: &[Token], range: &TokenRange, indent: u32) {

        writeln!(self.buffer, "Tokens: [");

        for token_index in range.start as usize..range.end as usize {

            write!(self.buffer, "{:?} (index {})", token.kind, token_index);

                writeln!(self.buffer, " text: {}", String::from_utf8_lossy(section));

        writeln!(self.buffer, "]");