#[cfg(feature = "onig")]

use onig::{Regex, RegexOptions};

use std::collections::HashMap;

use std::convert::TryInto;

use alloc_from_pool::{Factory as PoolFactory, PoolValue};

use crate::error::Diagnostics;

#[allow(unused_imports)]

use crate::nodes::*;

use crate::Loc;

use crate::{

Bytes, CurrentArgStack, Lexer, MaxNumparamStack, Node, SharedContext, StaticEnvironment, Token,

VariablesStack,

};

use crate::{Diagnostic, DiagnosticMessage, ErrorLevel};

#[derive(Debug, PartialEq)]

pub(crate) enum LoopType {

While,

Until,

}

#[derive(Debug, PartialEq)]

pub(crate) enum KeywordCmd {

Break,

Defined,

Next,

Redo,

Retry,

Return,

Super,

Yield,

Zsuper,

}

enum MethodCallType {

Send,

CSend,

}

#[derive(Debug, PartialEq)]

pub(crate) enum LogicalOp {

And,

Or,

}

#[derive(Debug, Clone)]

pub(crate) enum PKwLabel {

PlainLabel(PoolValue<Token>),

QuotedLabel((PoolValue<Token>, Vec<Node>, PoolValue<Token>)),

}

#[derive(Debug, Clone)]

pub(crate) enum ArgsType {

Args(Option<Box<Node>>),

Numargs(u8),

}

#[derive(Debug)]

pub(crate) struct Builder {

static_env: StaticEnvironment,

context: SharedContext,

current_arg_stack: CurrentArgStack,

max_numparam_stack: MaxNumparamStack,

pattern_variables: VariablesStack,

pattern_hash_keys: VariablesStack,

diagnostics: Diagnostics,

pool_factory: PoolFactory<Token>,

}

impl Builder {

pub(crate) fn new(

static_env: StaticEnvironment,

context: SharedContext,

current_arg_stack: CurrentArgStack,

max_numparam_stack: MaxNumparamStack,

pattern_variables: VariablesStack,

pattern_hash_keys: VariablesStack,

diagnostics: Diagnostics,

pool_factory: PoolFactory<Token>,

) -> Self {

Self {

static_env,

context,

current_arg_stack,

max_numparam_stack,

pattern_variables,

pattern_hash_keys,

diagnostics,

pool_factory,

}

}

//

// Literals

//

// Singletons

pub(crate) fn nil(&self, nil_t: PoolValue<Token>) -> Box<Node> {

Box::new(Node::Nil(Nil {

expression_l: self.loc(&nil_t),

}))

}

pub(crate) fn true_(&self, true_t: PoolValue<Token>) -> Box<Node> {

Box::new(Node::True(True {

expression_l: self.loc(&true_t),

}))

}

pub(crate) fn false_(&self, false_t: PoolValue<Token>) -> Box<Node> {

Box::new(Node::False(False {

expression_l: self.loc(&false_t),

}))

}

// Numerics

pub(crate) fn integer(&self, integer_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&integer_t);

Box::new(Node::Int(Int {

value: value(integer_t),

operator_l: None,

expression_l,

}))

}

pub(crate) fn float(&self, float_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&float_t);

Box::new(Node::Float(Float {

value: value(float_t),

operator_l: None,

expression_l,

}))

}

pub(crate) fn rational(&self, rational_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&rational_t);

Box::new(Node::Rational(Rational {

value: value(rational_t),

operator_l: None,

expression_l,

}))

}

pub(crate) fn complex(&self, complex_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&complex_t);

Box::new(Node::Complex(Complex {

value: value(complex_t),

operator_l: None,

expression_l,

}))

}

pub(crate) fn unary_num(&self, unary_t: PoolValue<Token>, mut numeric: Box<Node>) -> Box<Node> {

let new_operator_l = self.loc(&unary_t);

let sign = value(unary_t);

match &mut *numeric {

Node::Int(Int {

value,

expression_l,

operator_l,

})

| Node::Float(Float {

value,

expression_l,

operator_l,

})

| Node::Rational(Rational {

value,

operator_l,

expression_l,

})

| Node::Complex(Complex {

value,

operator_l,

expression_l,

}) => {

*value = format!("{}{}", sign, value);

*expression_l = new_operator_l.join(expression_l);

*operator_l = Some(new_operator_l);

}

_ => unreachable!(),

}

numeric

}

pub(crate) fn __line__(&self, line_t: PoolValue<Token>) -> Box<Node> {

Box::new(Node::Line(Line {

expression_l: self.loc(&line_t),

}))

}

// Strings

pub(crate) fn str_node(

&self,

begin_t: Option<PoolValue<Token>>,

value: Bytes,

parts: Vec<Node>,

end_t: Option<PoolValue<Token>>,

) -> Box<Node> {

if self.is_heredoc(&begin_t) {

let HeredocMap {

heredoc_body_l,

heredoc_end_l,

expression_l,

} = self.heredoc_map(&begin_t, &parts, &end_t);

Box::new(Node::Heredoc(Heredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}))

} else {

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&begin_t, &parts, &end_t);

Box::new(Node::Str(Str {

value,

begin_l,

end_l,

expression_l,

}))

}

}

pub(crate) fn string_internal(&self, mut string_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&string_t);

let value = string_t.take_value().token_value;

Box::new(Node::Str(Str {

value,

begin_l: None,

end_l: None,

expression_l,

}))

}

pub(crate) fn string_compose(

&self,

begin_t: Option<PoolValue<Token>>,

parts: Vec<Node>,

end_t: Option<PoolValue<Token>>,

) -> Box<Node> {

match &parts[..] {

[] => {

return self.str_node(begin_t, Bytes::empty(), parts, end_t);

}

[Node::Str(_) | Node::Dstr(_) | Node::Heredoc(_)]

if begin_t.is_none() && end_t.is_none() =>

{

return Box::new(

parts

.into_iter()

.next()

.expect("expected at least 1 element"),

);

}

[Node::Str(Str { value, .. })] => {

return self.str_node(begin_t, value.clone(), parts, end_t);

}

[Node::Dstr(_) | Node::Heredoc(_)] => {

unreachable!()

}

_ => {}

}

if self.is_heredoc(&begin_t) {

let HeredocMap {

heredoc_body_l,

heredoc_end_l,

expression_l,

} = self.heredoc_map(&begin_t, &parts, &end_t);

Box::new(Node::Heredoc(Heredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}))

} else {

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&begin_t, &parts, &end_t);

Box::new(Node::Dstr(Dstr {

parts,

begin_l,

end_l,

expression_l,

}))

}

}

pub(crate) fn character(&self, mut char_t: PoolValue<Token>) -> Box<Node> {

let str_loc = self.loc(&char_t);

let begin_l = Some(str_loc.with_end(str_loc.begin + 1));

let end_l = None;

let expression_l = str_loc;

let value = char_t.take_value().token_value;

Box::new(Node::Str(Str {

value,

begin_l,

end_l,

expression_l,

}))

}

pub(crate) fn __file__(&self, file_t: PoolValue<Token>) -> Box<Node> {

Box::new(Node::File(File {

expression_l: self.loc(&file_t),

}))

}

// Symbols

fn validate_sym_value(&self, value: &Bytes, loc: &Loc) {

if !value.is_valid_utf8() {

self.error(

DiagnosticMessage::InvalidSymbol {

symbol: String::from("UTF-8"),

},

loc,

)

}

}

pub(crate) fn symbol(

&self,

start_t: PoolValue<Token>,

mut value_t: PoolValue<Token>,

) -> Box<Node> {

let expression_l = self.loc(&start_t).join(&self.loc(&value_t));

let begin_l = Some(self.loc(&start_t));

let value = value_t.take_value().token_value;

self.validate_sym_value(&value, &expression_l);

Box::new(Node::Sym(Sym {

name: value,

begin_l,

end_l: None,

expression_l,

}))

}

pub(crate) fn symbol_internal(&self, mut symbol_t: PoolValue<Token>) -> Box<Node> {

let expression_l = self.loc(&symbol_t);

let value = symbol_t.take_value().token_value;

self.validate_sym_value(&value, &expression_l);

Box::new(Node::Sym(Sym {

name: value,

begin_l: None,

end_l: None,

expression_l,

}))

}

pub(crate) fn symbol_compose(

&self,

begin_t: PoolValue<Token>,

parts: Vec<Node>,

end_t: PoolValue<Token>,

) -> Box<Node> {

if parts.len() == 1 && matches!(&parts[0], Node::Str(_)) {

match parts.into_iter().next().unwrap() {

Node::Str(Str { value, .. }) => {

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&Some(begin_t), &[], &Some(end_t));

self.validate_sym_value(&value, &expression_l);

return Box::new(Node::Sym(Sym {

name: value,

begin_l,

end_l,

expression_l,

}));

}

_ => unreachable!(),

}

}

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&Some(begin_t), &parts, &Some(end_t));

Box::new(Node::Dsym(Dsym {

parts,

begin_l,

end_l,

expression_l,

}))

}

// Executable strings

pub(crate) fn xstring_compose(

&self,

begin_t: PoolValue<Token>,

parts: Vec<Node>,

end_t: PoolValue<Token>,

) -> Box<Node> {

let begin_l = self.loc(&begin_t);

let begin = &begin_t.token_value;

if begin.len() >= 2 && begin[0] == b'<' && begin[1] == b'<' {

let heredoc_body_l = collection_expr(&parts).unwrap_or_else(|| self.loc(&end_t));

let heredoc_end_l = self.loc(&end_t);

let expression_l = begin_l;

Box::new(Node::XHeredoc(XHeredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}))

} else {

let end_l = self.loc(&end_t);

let expression_l = begin_l.join(&end_l);

Box::new(Node::Xstr(Xstr {

parts,

begin_l,

end_l,

expression_l,

}))

}

}

// Indented (interpolated, noninterpolated, executable) strings

pub(crate) fn heredoc_dedent(&self, node: Box<Node>, dedent_level: i32) -> Box<Node> {

if dedent_level == 0 {

return node;

}

let dedent_level: usize = dedent_level

.try_into()

.expect("dedent_level must be positive");

let dedent_heredoc_parts = |parts: Vec<Node>| -> Vec<Node> {

parts

.into_iter()

.filter_map(|part| match part {

Node::Str(Str {

value,

begin_l,

end_l,

expression_l,

}) => {

let value = Self::dedent_string(value, dedent_level);

if value.is_empty() {

None

} else {

Some(Node::Str(Str {

value,

begin_l,

end_l,

expression_l,

}))

}

}

Node::Begin(_)

| Node::Gvar(_)

| Node::BackRef(_)

| Node::NthRef(_)

| Node::Ivar(_)

| Node::Cvar(_) => Some(part),

other => {

unreachable!("unsupported heredoc child {}", other.str_type())

}

})

.collect::<Vec<_>>()

};

match *node {

Node::Heredoc(Heredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}) => {

let parts = dedent_heredoc_parts(parts);

Box::new(Node::Heredoc(Heredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}))

}

Node::XHeredoc(XHeredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}) => {

let parts = dedent_heredoc_parts(parts);

Box::new(Node::XHeredoc(XHeredoc {

parts,

heredoc_body_l,

heredoc_end_l,

expression_l,

}))

}

_ => {

unreachable!("unsupported heredoc_dedent argument {}", node.str_type())

}

}

}

const TAB_WIDTH: usize = 8;

pub(crate) fn dedent_string(s: Bytes, width: usize) -> Bytes {

let mut col: usize = 0;

let mut i: usize = 0;

loop {

if !(i < s.len() && col < width) {

break;

}

if s[i] == b' ' {

col += 1;

} else if s[i] == b'\t' {

let n = Self::TAB_WIDTH * (col / Self::TAB_WIDTH + 1);

if n > Self::TAB_WIDTH {

break;

}

col = n;

} else {

break;

}

i += 1;

}

Bytes::new(Vec::from(&s.as_raw()[i..]))

}

// Regular expressions

pub(crate) fn regexp_options(&self, regexp_end_t: PoolValue<Token>) -> Option<Box<Node>> {

if regexp_end_t.loc.end - regexp_end_t.loc.begin == 1 {

// no regexp options, only trailing "/"

return None;

}

let expression_l = self.loc(&regexp_end_t).adjust_begin(1);

let options = value(regexp_end_t);

let mut options = options.as_str().chars().skip(1).collect::<Vec<_>>();

options.sort_unstable();

options.dedup();

let options = if options.is_empty() {

None

} else {

Some(options.into_iter().collect::<String>())

};

Some(Box::new(Node::RegOpt(RegOpt {

options,

expression_l,

})))

}

pub(crate) fn regexp_compose(

&self,

begin_t: PoolValue<Token>,

parts: Vec<Node>,

end_t: PoolValue<Token>,

options: Option<Box<Node>>,

) -> Box<Node> {

let begin_l = self.loc(&begin_t);

let end_l = self.loc(&end_t).resize(1);

let expression_l =

begin_l.join(&maybe_boxed_node_expr(&options).unwrap_or_else(|| self.loc(&end_t)));

match options.as_deref() {

Some(Node::RegOpt(RegOpt {

options,

expression_l,

})) => self.validate_static_regexp(&parts, options, expression_l),

None => self.validate_static_regexp(&parts, &None, &expression_l),

_ => unreachable!("must be Option<RegOpt>"),

}

Box::new(Node::Regexp(Regexp {

parts,

options,

begin_l,

end_l,

expression_l,

}))

}

// Arrays

pub(crate) fn array(

&self,

begin_t: Option<PoolValue<Token>>,

elements: Vec<Node>,

end_t: Option<PoolValue<Token>>,

) -> Box<Node> {

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&begin_t, &elements, &end_t);

Box::new(Node::Array(Array {

elements,

begin_l,

end_l,

expression_l,

}))

}

pub(crate) fn splat(&self, star_t: PoolValue<Token>, value: Option<Box<Node>>) -> Box<Node> {

let operator_l = self.loc(&star_t);

let expression_l = operator_l.maybe_join(&maybe_boxed_node_expr(&value));

Box::new(Node::Splat(Splat {

value,

operator_l,

expression_l,

}))

}

pub(crate) fn word(&self, parts: Vec<Node>) -> Box<Node> {

if parts.len() == 1 && matches!(&parts[0], Node::Str(_) | Node::Dstr(_)) {

let part = parts

.into_iter()

.next()

.expect("parts is supposed to have exactly 1 element");

return Box::new(part);

}

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&None, &parts, &None);

Box::new(Node::Dstr(Dstr {

parts,

begin_l,

end_l,

expression_l,

}))

}

pub(crate) fn words_compose(

&self,

begin_t: PoolValue<Token>,

elements: Vec<Node>,

end_t: PoolValue<Token>,

) -> Box<Node> {

let begin_l = self.loc(&begin_t);

let end_l = self.loc(&end_t);

let expression_l = begin_l.join(&end_l);

Box::new(Node::Array(Array {

elements,

begin_l: Some(begin_l),

end_l: Some(end_l),

expression_l,

}))

}

pub(crate) fn symbols_compose(

&self,

begin_t: PoolValue<Token>,

parts: Vec<Node>,

end_t: PoolValue<Token>,

) -> Box<Node> {

let parts = parts

.into_iter()

.map(|part| match part {

Node::Str(Str {

value,

begin_l,

end_l,

expression_l,

}) => {

self.validate_sym_value(&value, &expression_l);

Node::Sym(Sym {

name: value,

begin_l,

end_l,

expression_l,

})

}

Node::Dstr(Dstr {

parts,

begin_l,

end_l,

expression_l,

}) => Node::Dsym(Dsym {

parts,

begin_l,

end_l,

expression_l,

}),

other => other,

})

.collect::<Vec<_>>();

let begin_l = self.loc(&begin_t);

let end_l = self.loc(&end_t);

let expression_l = begin_l.join(&end_l);

Box::new(Node::Array(Array {

elements: parts,

begin_l: Some(begin_l),

end_l: Some(end_l),

expression_l,

}))

}

// Hashes

pub(crate) fn pair(

&self,

key: Box<Node>,

assoc_t: PoolValue<Token>,

value: Box<Node>,

) -> Box<Node> {

let operator_l = self.loc(&assoc_t);

let expression_l = join_exprs(&key, &value);

Box::new(Node::Pair(Pair {

key,

value,

operator_l,

expression_l,

}))

}

pub(crate) fn pair_keyword(&self, mut key_t: PoolValue<Token>, value: Box<Node>) -> Box<Node> {

let key_loc = self.loc(&key_t);

let key_l = key_loc.adjust_end(-1);

let colon_l = key_loc.with_begin(key_loc.end - 1);

let expression_l = key_loc.join(value.expression());

let key = key_t.take_value().token_value;

self.validate_sym_value(&key, &key_l);

Box::new(Node::Pair(Pair {

key: Box::new(Node::Sym(Sym {

name: key,

begin_l: None,

end_l: None,

expression_l: key_l,

})),

value,

operator_l: colon_l,

expression_l,

}))

}

pub(crate) fn pair_quoted(

&self,

begin_t: PoolValue<Token>,

parts: Vec<Node>,

end_t: PoolValue<Token>,

value: Box<Node>,

) -> Box<Node> {

let end_l = self.loc(&end_t);

let quote_loc = Loc {

begin: end_l.end - 2,

end: end_l.end - 1,

};

let colon_l = end_l.with_begin(end_l.end - 1);

let mut end_t = end_t;

let end_t: PoolValue<Token> = self.pool_factory.alloc(Token {

token_type: end_t.token_type,

token_value: end_t.take_value().token_value,

loc: quote_loc,

});

let expression_l = self.loc(&begin_t).join(value.expression());

Box::new(Node::Pair(Pair {

key: self.symbol_compose(begin_t, parts, end_t),

value,

operator_l: colon_l,

expression_l,

}))

}

pub(crate) fn pair_label(&self, key_t: PoolValue<Token>) -> Box<Node> {

let key_l = self.loc(&key_t);

let value_l = key_l.adjust_end(-1);

let label = value(key_t.clone());

let value = if label

.chars()

.next()

.expect("bug: label can't be empty")

.is_lowercase()

{

Box::new(Node::Lvar(Lvar {

name: label,

expression_l: value_l,

}))

} else {

Box::new(Node::Const(Const {

scope: None,

name: label,

double_colon_l: None,

name_l: value_l,

expression_l: value_l,

}))

};

self.pair_keyword(key_t, self.accessible(value))

}

pub(crate) fn kwsplat(&self, dstar_t: PoolValue<Token>, value: Box<Node>) -> Box<Node> {

let operator_l = self.loc(&dstar_t);

let expression_l = value.expression().join(&operator_l);

Box::new(Node::Kwsplat(Kwsplat {

value,

operator_l,

expression_l,

}))

}

pub(crate) fn associate(

&self,

begin_t: Option<PoolValue<Token>>,

pairs: Vec<Node>,

end_t: Option<PoolValue<Token>>,

) -> Box<Node> {

for i in 0..pairs.len() {

for j in i + 1..pairs.len() {

let key1 = if let Node::Pair(Pair { key, .. }) = &pairs[i] {

&**key

} else {

// kwsplat

continue;

};

let key2 = if let Node::Pair(Pair { key, .. }) = &pairs[j] {

&**key

} else {

// kwsplat

continue;

};

fn keys_are_equal(left: &Node, right: &Node) -> bool {

match (left, right) {

// sym

(

Node::Sym(Sym { name: name1, .. }),

Node::Sym(Sym { name: name2, .. }),

) if name1 == name2 => true,

// str

(

Node::Str(Str { value: value1, .. }),

Node::Str(Str { value: value2, .. }),

) if value1 == value2 => true,

// int

(

Node::Int(Int { value: value1, .. }),

Node::Int(Int { value: value2, .. }),

) if value1 == value2 => true,

// float

(

Node::Float(Float { value: value1, .. }),

Node::Float(Float { value: value2, .. }),

) if value1 == value2 => true,

// rational

(

Node::Rational(Rational { value: value1, .. }),

Node::Rational(Rational { value: value2, .. }),

) if value1 == value2 => true,

// complex

(

Node::Complex(Complex { value: value1, .. }),

Node::Complex(Complex { value: value2, .. }),

) if value1 == value2 => true,

// regexp

(

Node::Regexp(Regexp {

parts: parts1,

options: options1,

..

}),

Node::Regexp(Regexp {

parts: parts2,

options: options2,

..

}),

) if options1 == options2 => {

parts1.len() == parts2.len()

&& parts1

.iter()

.zip(parts2.iter())

.all(|(child1, child2)| keys_are_equal(child1, child2))

}

_ => false,

}

}

let do_warn = keys_are_equal(key1, key2);

if do_warn {

self.warn(DiagnosticMessage::DuplicateHashKey {}, key2.expression());

}

}

}

let CollectionMap {

begin_l,

end_l,

expression_l,

} = self.collection_map(&begin_t, &pairs, &end_t);

Box::new(Node::Hash(Hash {

pairs,

begin_l,

end_l,

expression_l,

}))

}

// Ranges

pub(crate) fn range_inclusive(

&self,

left: Option<Box<Node>>,

dot2_t: PoolValue<Token>,

right: Option<Box<Node>>,

) -> Box<Node> {

let operator_l = self.loc(&dot2_t);

let expression_l = operator_l

.maybe_join(&maybe_boxed_node_expr(&left))

.maybe_join(&maybe_boxed_node_expr(&right));

Box::new(Node::Irange(Irange {

left,

right,

operator_l,

expression_l,

}))

}

pub(crate) fn range_exclusive(

&self,

left: Option<Box<Node>>,

dot3_t: PoolValue<Token>,

right: Option<Box<Node>>,

) -> Box<Node> {

let operator_l = self.loc(&dot3_t);

let expression_l = operator_l

.maybe_join(&maybe_boxed_node_expr(&left))

.maybe_join(&maybe_boxed_node_expr(&right));

Box::new(Node::Erange(Erange {

left,

right,

operator_l,

expression_l,

}))

}

//

// Access

//

pub(crate) fn self_(&self, token: PoolValue<Token>) -> Box<Node> {

Box::new(Node::Self_(Self_ {

expression_l: self.loc(&token),

}))

}