Skip to content

Commit

Permalink
Simplify get_pattern_register
Browse files Browse the repository at this point in the history
  • Loading branch information
@voltrevo
voltrevo committed Jul 6, 2023
1 parent 2952d69 commit 262ac43
Show file tree
Hide file tree
Showing 2 changed files with 28 additions and 52 deletions.
25 changes: 3 additions & 22 deletions valuescript_compiler/src/expression_compiler.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1385,13 +1385,7 @@ impl<'a> ExpressionCompiler<'a> {

match pat {
Pat::Ident(ident) => {
let ident_reg = match self.fnc.get_pattern_register(pat) {
Some(r) => r,
None => {
self.fnc.error(pat.span(), &"Invalid pattern".to_string());
self.fnc.allocate_reg(&"_invalid_pattern".to_string())
}
};
let ident_reg = self.fnc.get_pattern_register(pat);

if register != &ident_reg {
self.fnc.diagnostics.push(Diagnostic {
Expand Down Expand Up @@ -1431,13 +1425,7 @@ impl<'a> ExpressionCompiler<'a> {
None => continue,
};

let elem_reg = match self.fnc.get_pattern_register(elem) {
Some(r) => r,
None => {
self.fnc.error(elem.span(), "Invalid pattern");
self.fnc.allocate_reg(&"_invalid_pattern".to_string())
}
};
let elem_reg = self.fnc.get_pattern_register(elem);

self.fnc.push(Instruction::Sub(
Value::Register(register.clone()),
Expand All @@ -1458,14 +1446,7 @@ impl<'a> ExpressionCompiler<'a> {

match prop {
ObjectPatProp::KeyValue(kv) => {
let param_reg = match self.fnc.get_pattern_register(&kv.value) {
Some(r) => r,
None => {
self.fnc.error(kv.value.span(), "Invalid pattern");
self.fnc.allocate_reg(&"_invalid_pattern".to_string())
}
};

let param_reg = self.fnc.get_pattern_register(&kv.value);
let compiled_key = self.prop_name(&kv.key);

self.fnc.push(Instruction::Sub(
Expand Down
55 changes: 25 additions & 30 deletions valuescript_compiler/src/function_compiler.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -388,12 +388,12 @@ impl FunctionCompiler {
match functionish {
Functionish::Fn(_, fn_) => {
for p in &fn_.params {
param_registers.push(self.get_pattern_register(&p.pat));
param_registers.push(self.get_pattern_register_opt(&p.pat));
}
}
Functionish::Arrow(arrow) => {
for p in &arrow.params {
param_registers.push(self.get_pattern_register(p));
param_registers.push(self.get_pattern_register_opt(p));
}
}
Functionish::Constructor(_, _class_span, constructor) => {
Expand All @@ -406,7 +406,7 @@ impl FunctionCompiler {
));
}
swc_ecma_ast::ParamOrTsParamProp::Param(p) => {
param_registers.push(self.get_pattern_register(&p.pat))
param_registers.push(self.get_pattern_register_opt(&p.pat))
}
}
}
Expand All @@ -416,15 +416,15 @@ impl FunctionCompiler {
return param_registers;
}

pub fn get_pattern_register(&mut self, param_pat: &swc_ecma_ast::Pat) -> Option<Register> {
pub fn get_pattern_register_opt(&mut self, param_pat: &swc_ecma_ast::Pat) -> Option<Register> {
use swc_ecma_ast::Pat;

Some(match param_pat {
Pat::Ident(ident) => match ident.id.sym.to_string().as_str() {
"this" => return None,
_ => self.get_variable_register(&ident.id),
},
Pat::Assign(assign) => return self.get_pattern_register(&assign.left),
Pat::Assign(assign) => return self.get_pattern_register_opt(&assign.left),
Pat::Array(_) => self.allocate_numbered_reg(&"_array_pat".to_string()),
Pat::Object(_) => self.allocate_numbered_reg(&"_object_pat".to_string()),
Pat::Invalid(_) => self.allocate_numbered_reg(&"_invalid_pat".to_string()),
Expand All @@ -433,6 +433,16 @@ impl FunctionCompiler {
})
}

pub fn get_pattern_register(&mut self, param_pat: &swc_ecma_ast::Pat) -> Register {
match self.get_pattern_register_opt(param_pat) {
Some(r) => r,
None => {
self.error(param_pat.span(), "Invalid pattern");
self.allocate_reg(&"_invalid_pattern".to_string())
}
}
}

pub fn get_variable_register(&mut self, ident: &swc_ecma_ast::Ident) -> Register {
match self.scope_analysis.lookup_value(&self.owner_id, ident) {
Some(Value::Register(reg)) => reg,
Expand Down Expand Up @@ -849,17 +859,15 @@ impl FunctionCompiler {
if let Some(param) = &catch_clause.param {
let mut ec = ExpressionCompiler { fnc: self };

if let Some(pattern_reg) = ec.fnc.get_pattern_register(&param) {
// TODO: Set up this register through set_catch instead of copying into it
ec.fnc.push(Instruction::Mov(
Value::Register(catch_error_reg.unwrap()),
pattern_reg.clone(),
));
let pattern_reg = ec.fnc.get_pattern_register(&param);

ec.pat(&param, &pattern_reg, false);
} else {
ec.fnc.error(param.span(), "Invalid catch pattern");
}
// TODO: Set up this register through set_catch instead of copying into it
ec.fnc.push(Instruction::Mov(
Value::Register(catch_error_reg.unwrap()),
pattern_reg.clone(),
));

ec.pat(&param, &pattern_reg, false);
}

self.block_statement(&catch_clause.body);
Expand Down Expand Up @@ -1132,14 +1140,7 @@ impl FunctionCompiler {
swc_ecma_ast::VarDeclOrPat::Pat(pat) => pat,
};

let value_reg = match ec.fnc.get_pattern_register(pat) {
Some(value_reg) => value_reg,
None => {
ec.fnc
.error(pat.span(), "Loop variable has invalid pattern");
ec.fnc.allocate_reg(&"_invalid_pattern".to_string())
}
};
let value_reg = ec.fnc.get_pattern_register(pat);

let iter_reg = ec.fnc.allocate_numbered_reg(&"_iter".to_string());
let iter_res_reg = ec.fnc.allocate_numbered_reg(&"_iter_res".to_string());
Expand Down Expand Up @@ -1255,13 +1256,7 @@ impl FunctionCompiler {
for decl in &var_decl.decls {
match &decl.init {
Some(expr) => {
let target_register = match self.get_pattern_register(&decl.name) {
Some(tr) => tr,
None => {
self.error(decl.name.span(), "Invalid pattern");
self.allocate_reg(&"_invalid_pattern".to_string())
}
};
let target_register = self.get_pattern_register(&decl.name);

let mut ec = ExpressionCompiler { fnc: self };
ec.compile_into(expr, target_register.clone());
Expand Down

0 comments on commit 262ac43

Please sign in to comment.