Refactored 'inflow' abstraction into 'infinite iterator'

Author: IsaacShelton

Cargo.lock

@@ -32,7 +32,7 @@ members = [
     "src/representations/interpreter_api",
     "src/support/std_ext",
     "src/support/compiler",
-    "src/support/inflow",
+    "src/support/infinite_iterator",
     "src/support/text",
     "src/representations/token",
     "src/components/build_token",

Cargo.toml

@@ -10,7 +10,7 @@ derivative.workspace = true
 derive_more.workspace = true
 diagnostics = { version = "0.1.0", path = "../../support/diagnostics" }
 indexmap.workspace = true
-inflow = { version = "0.1.0", path = "../../support/inflow" }
+infinite_iterator = { version = "0.1.0", path = "../../support/infinite_iterator" }
 lazy_format.workspace = true
 num.workspace = true
 num-bigint.workspace = true

src/components/build_ast/Cargo.toml

@@ -1,42 +1,42 @@
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::{Source, SourceFileKey, SourceFiles};
 use std::{borrow::Borrow, fmt::Debug};
 use token::{Token, TokenKind};
 
-pub struct Input<'a, I: Inflow<Token>> {
+pub struct Input<'a, I: InfinitePeekable<Token>> {
     source_files: &'a SourceFiles,
-    inflow: I,
+    infinite_peekable: I,
     key: SourceFileKey,
 }
 
-impl<'a, I: Inflow<Token>> Debug for Input<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Debug for Input<'a, I> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Input<Inflow<Token>>").finish()
+        f.debug_struct("Input<InfiniteIterator<Token>>").finish()
     }
 }
 
 impl<'a, I> Input<'a, I>
 where
-    I: Inflow<Token>,
+    I: InfinitePeekable<Token>,
 {
-    pub fn new(inflow: I, source_files: &'a SourceFiles, key: SourceFileKey) -> Self {
+    pub fn new(infinite_peekable: I, source_files: &'a SourceFiles, key: SourceFileKey) -> Self {
         Self {
-            inflow,
+            infinite_peekable,
             source_files,
             key,
         }
     }
 
     pub fn peek(&mut self) -> &Token {
-        self.inflow.peek_nth(0)
+        self.infinite_peekable.peek_nth(0)
     }
 
     pub fn peek_nth(&mut self, n: usize) -> &Token {
-        self.inflow.peek_nth(n)
+        self.infinite_peekable.peek_nth(n)
     }
 
     pub fn peek_n<const N: usize>(&mut self) -> [&Token; N] {
-        self.inflow.peek_n::<N>()
+        self.infinite_peekable.peek_n::<N>()
     }
 
     pub fn peek_is(&mut self, token: impl Borrow<TokenKind>) -> bool {
@@ -49,7 +49,7 @@ where
     }
 
     pub fn advance(&mut self) -> Token {
-        self.inflow.next()
+        self.infinite_peekable.next()
     }
 
     pub fn eat(&mut self, token: impl Borrow<TokenKind>) -> bool {
@@ -102,6 +102,6 @@ where
     // Adds input to the front of the queue,
     // useful for partially consuming tokens during parsing.
     pub fn unadvance(&mut self, token: Token) {
-        self.inflow.un_next(token)
+        self.infinite_peekable.un_next(token)
     }
 }

src/components/build_ast/src/input.rs

@@ -25,25 +25,25 @@ mod parse_util;
 use self::error::ParseError;
 pub use self::input::Input;
 use ast::AstFile;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::{Source, SourceFileKey, SourceFiles};
 use std::mem::MaybeUninit;
 use token::{Token, TokenKind};
 
 pub fn parse(
-    tokens: impl Inflow<Token>,
+    tokens: impl InfinitePeekable<Token>,
     source_files: &SourceFiles,
     key: SourceFileKey,
 ) -> Result<AstFile, ParseError> {
     Parser::new(Input::new(tokens, source_files, key)).parse()
 }
 
-pub struct Parser<'a, I: Inflow<Token>> {
+pub struct Parser<'a, I: InfinitePeekable<Token>> {
     pub input: Input<'a, I>,
     pub treat_string_literals_as_cstring_literals: bool,
 }
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn new(input: Input<'a, I>) -> Self {
         Self {
             input,

src/components/build_ast/src/lib.rs

@@ -3,11 +3,11 @@ use super::{
     annotation::Annotation,
     error::{ParseError, ParseErrorKind},
 };
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::Source;
 use token::{Token, TokenKind};
 
-impl<I: Inflow<Token>> Parser<'_, I> {
+impl<I: InfinitePeekable<Token>> Parser<'_, I> {
     pub fn unexpected_token_is_next(&mut self) -> ParseError {
         let unexpected = self.input.advance();
         self.unexpected_token(&unexpected)

src/components/build_ast/src/make_error.rs

@@ -4,10 +4,10 @@ use super::{
     error::{ParseError, ParseErrorKind},
 };
 use ast::Given;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_annotation(&mut self) -> Result<Vec<Annotation>, ParseError> {
         // #[annotation_name]
         // ^

src/components/build_ast/src/parse_annotation.rs

@@ -1,10 +1,10 @@
 use super::{Parser, error::ParseError};
 use ast::Stmt;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use lazy_format::lazy_format;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_block(&mut self, to_begin_what_block: &str) -> Result<Vec<Stmt>, ParseError> {
         self.ignore_newlines();
 

src/components/build_ast/src/parse_block.rs

@@ -3,11 +3,11 @@ use crate::annotation::AnnotationKind;
 use ast::{Enum, EnumMember};
 use attributes::Privacy;
 use indexmap::IndexMap;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use num::{BigInt, Zero};
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_enum(&mut self, annotations: Vec<Annotation>) -> Result<Enum, ParseError> {
         let source = self.source_here();
         assert!(self.input.advance().is_enum_keyword());

src/components/build_ast/src/parse_enum.rs

@@ -3,10 +3,10 @@ mod primary;
 
 use super::{ParseError, Parser, is_right_associative, is_terminating_token};
 use ast::Expr;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::Token;
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_expr(&mut self) -> Result<Expr, ParseError> {
         let primary = self.parse_expr_primary()?;
         self.parse_operator_expr(0, primary)

src/components/build_ast/src/parse_expr/mod.rs

@@ -1,10 +1,10 @@
 use super::Parser;
 use crate::error::ParseError;
 use ast::{ArrayAccess, Expr, ExprKind};
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_array_access(&mut self, subject: Expr) -> Result<Expr, ParseError> {
         // subject[index]
         //        ^

src/components/build_ast/src/parse_expr/post/array_access.rs

@@ -2,10 +2,10 @@ use super::Parser;
 use crate::{error::ParseError, parse_util::into_plain_name};
 use ast::{Expr, ExprKind};
 use attributes::Privacy;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_member(&mut self, subject: Expr) -> Result<Expr, ParseError> {
         // subject.field_name
         //        ^

src/components/build_ast/src/parse_expr/post/member.rs

@@ -4,10 +4,10 @@ mod member;
 use super::Parser;
 use crate::error::ParseError;
 use ast::Expr;
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_expr_primary_post(&mut self, mut base: Expr) -> Result<Expr, ParseError> {
         let mut ate_newline;
 

src/components/build_ast/src/parse_expr/post/mod.rs

@@ -1,11 +1,11 @@
 use super::Parser;
 use crate::error::ParseError;
 use ast::{Call, Expr, ExprKind, Name, TypeArg, Using};
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::Source;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_call(
         &mut self,
         name: Name,

src/components/build_ast/src/parse_expr/primary/call.rs

@@ -1,11 +1,11 @@
 use super::Parser;
 use crate::error::ParseError;
 use ast::{DeclareAssign, Expr, ExprKind};
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::Source;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_declare_assign(
         &mut self,
         variable_name: String,

src/components/build_ast/src/parse_expr/primary/declare_assign.rs

@@ -10,11 +10,11 @@ use ast::{
     Block, Conditional, Expr, ExprKind, Integer, TypeArg, TypeKind, UnaryMathOperator,
     UnaryOperation, UnaryOperator, While,
 };
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use std::ffi::CString;
 use token::{StringLiteral, StringModifier, Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_expr_primary(&mut self) -> Result<Expr, ParseError> {
         let expr = self.parse_expr_primary_base()?;
         self.parse_expr_primary_post(expr)

src/components/build_ast/src/parse_expr/primary/mod.rs

@@ -4,11 +4,11 @@ use ast::{
     BasicBinaryOperation, BasicBinaryOperator, BinaryOperator, Expr, ExprKind, Language,
     ShortCircuitingBinaryOperation, ShortCircuitingBinaryOperator,
 };
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::Source;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_operator_expr(
         &mut self,
         precedence: usize,

src/components/build_ast/src/parse_expr/primary/operator.rs

@@ -1,11 +1,11 @@
 use super::Parser;
 use crate::error::{ParseError, ParseErrorKind};
 use ast::{Expr, ExprKind, Name, StaticMemberCall, StaticMemberValue, Type, TypeArg};
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use source_files::Source;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_static_member(
         &mut self,
         type_name: Name,

src/components/build_ast/src/parse_expr/primary/static_member.rs

@@ -1,9 +1,9 @@
 use super::{ParseError, Parser};
 use ast::{Expr, ExprKind, FieldInitializer, FillBehavior, Language, Name, StructLiteral, Type};
-use inflow::Inflow;
+use infinite_iterator::InfinitePeekable;
 use token::{Token, TokenKind};
 
-impl<'a, I: Inflow<Token>> Parser<'a, I> {
+impl<'a, I: InfinitePeekable<Token>> Parser<'a, I> {
     pub fn parse_struct_literal(&mut self) -> Result<Expr, ParseError> {
         // Type { x: VALUE, b: VALUE, c: VALUE, :d, :e, ..SPECIFIER }
         //  ^