Update (and pin) full-moon version, which supports Typed Lua

Kampfkarren · Jan 19, 2020 · 1b81a70 · 1b81a70
1 parent b50991d
commit 1b81a70
Show file tree

Hide file tree

Showing 12 changed files with 74 additions and 32 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/selene-lib/Cargo.toml b/selene-lib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "selene-lib"
-version = "0.5.0"
+version = "0.5.1"
 license = "MPL-2.0"
 authors = ["Kampfkarren <[email protected]>"]
 description = "A library for linting Lua code. You probably want selene instead."
@@ -12,7 +12,7 @@ edition = "2018"
 [dependencies]
 codespan = "0.4"
 codespan-reporting = "0.4"
-full_moon = "0.4.0-rc.12"
+full_moon = "=0.4.0-rc.13"
 id-arena = "2.2"
 if_chain = "1.0"
 lazy_static = "1.4"

diff --git a/selene-lib/src/ast_util/scopes.rs b/selene-lib/src/ast_util/scopes.rs
@@ -156,7 +156,7 @@ impl ScopeVisitor {
                 self.read_expression(expression);
             }
 
-            ast::Expression::Value { value, binop } => {
+            ast::Expression::Value { value, binop, .. } => {
                 if let Some(binop) = binop {
                     self.read_expression(binop.rhs());
                 }

diff --git a/selene-lib/src/rules/divide_by_zero.rs b/selene-lib/src/rules/divide_by_zero.rs
@@ -61,7 +61,7 @@ fn value_is_zero(value: &ast::Value) -> bool {
 impl Visitor<'_> for DivideByZeroVisitor {
     fn visit_expression(&mut self, node: &ast::Expression) {
         if_chain::if_chain! {
-            if let ast::Expression::Value { value, binop } = node;
+            if let ast::Expression::Value { value, binop, .. } = node;
             if let Some(rhs) = binop;
             if let ast::BinOp::Slash(_) = rhs.bin_op();
             if let ast::Expression::Value {

diff --git a/selene-lib/src/rules/parenthese_conditions.rs b/selene-lib/src/rules/parenthese_conditions.rs
@@ -54,7 +54,7 @@ impl ParentheseConditionsVisitor {
     fn lint_condition(&mut self, condition: &ast::Expression) {
         let is_parentheses = match condition {
             ast::Expression::Parentheses { .. } => true,
-            ast::Expression::Value { value, binop } => {
+            ast::Expression::Value { value, binop, .. } => {
                 if let ast::Value::ParseExpression(_) = &**value {
                     binop.is_none()
                 } else {

diff --git a/selene-lib/src/rules/roblox_incorrect_color3_new_bounds.rs b/selene-lib/src/rules/roblox_incorrect_color3_new_bounds.rs
@@ -78,7 +78,7 @@ impl Visitor<'_> for Color3BoundsVisitor {
                 for argument in arguments {
                     // Check if the argument is a constant number
                     if_chain::if_chain! {
-                        if let ast::Expression::Value { value, binop } = argument;
+                        if let ast::Expression::Value { value, binop, .. } = argument;
                         if binop.is_none();
                         if let ast::Value::Number(value) = &**value;
                         if let Ok(number) = value.to_string().parse::<f32>();

diff --git a/selene-lib/src/rules/roblox_incorrect_roact_usage.rs b/selene-lib/src/rules/roblox_incorrect_roact_usage.rs
@@ -159,14 +159,14 @@ impl Visitor<'_> for IncorrectRoactUsageVisitor {
 
             // Get first argument, check if it is a Roblox class
             let name_arg = iter.next().unwrap();
-            if let ast::Expression::Value { value, binop } = name_arg;
+            if let ast::Expression::Value { value, binop, .. } = name_arg;
             if binop.is_none();
             if let ast::Value::String(token) = &**value;
             if let Some(class) = self.check_class_name(&token);
 
             // Get second argument, check if it is a table
             let arg = iter.next().unwrap();
-            if let ast::Expression::Value { value, binop } = arg;
+            if let ast::Expression::Value { value, binop, .. } = arg;
             if binop.is_none();
             if let ast::Value::TableConstructor(table) = &**value;
 
@@ -210,7 +210,7 @@ impl Visitor<'_> for IncorrectRoactUsageVisitor {
     fn visit_local_assignment(&mut self, node: &ast::LocalAssignment) {
         for (name, expr) in node.name_list().iter().zip(node.expr_list().iter()) {
             if_chain! {
-                if let ast::Expression::Value { value, binop } = expr;
+                if let ast::Expression::Value { value, binop, .. } = expr;
                 if binop.is_none();
                 if let ast::Value::Var(var) = &**value;
                 if let ast::Var::Expression(var_expr) = var;

diff --git a/selene-lib/src/rules/standard_library.rs b/selene-lib/src/rules/standard_library.rs
@@ -119,7 +119,9 @@ fn get_argument_type(expression: &ast::Expression) -> Option<PassedArgumentType>
             }
         }
 
-        ast::Expression::Value { binop: rhs, value } => {
+        ast::Expression::Value {
+            binop: rhs, value, ..
+        } => {
             let base = match &**value {
                 ast::Value::Function(_) => Some(ArgumentType::Function.into()),
                 ast::Value::FunctionCall(_) => None,

diff --git a/selene-lib/src/rules/suspicious_reverse_loop.rs b/selene-lib/src/rules/suspicious_reverse_loop.rs
@@ -58,7 +58,7 @@ impl Visitor<'_> for SuspiciousReverseLoopVisitor {
             if node.step().is_none();
             if let ast::Expression::UnaryOperator { unop, .. } = node.start();
             if let ast::UnOp::Hash(_) = unop;
-            if let ast::Expression::Value { value, binop } = node.end();
+            if let ast::Expression::Value { value, binop, .. } = node.end();
             if binop.is_none();
             if let ast::Value::Number(number) = &**value;
             if str::parse::<f32>(&number.to_string()).unwrap() <= 1.0;

diff --git a/selene-lib/src/rules/type_check_inside_call.rs b/selene-lib/src/rules/type_check_inside_call.rs
@@ -73,7 +73,7 @@ impl Visitor<'_> for TypeCheckInsideCallVisitor {
             if let ast::BinOp::TwoEqual(_) = rhs.bin_op();
 
             // Check that rhs is a constant string
-            if let ast::Expression::Value { binop: rhs, value } = rhs.rhs();
+            if let ast::Expression::Value { binop: rhs, value, .. } = rhs.rhs();
             if rhs.is_none();
             if let ast::Value::String(_) = &**value;
 

diff --git a/selene-lib/src/rules/unbalanced_assignments.rs b/selene-lib/src/rules/unbalanced_assignments.rs
@@ -75,7 +75,7 @@ struct UnbalancedAssignmentsVisitor {
 fn expression_is_call(expression: &ast::Expression) -> bool {
     match expression {
         ast::Expression::Parentheses { expression, .. } => expression_is_call(expression),
-        ast::Expression::Value { value, binop } => {
+        ast::Expression::Value { value, binop, .. } => {
             if binop.is_none() {
                 if let ast::Value::FunctionCall(_) = &**value {
                     true
@@ -94,7 +94,7 @@ fn expression_is_call(expression: &ast::Expression) -> bool {
 fn expression_is_nil(expression: &ast::Expression) -> bool {
     match expression {
         ast::Expression::Parentheses { expression, .. } => expression_is_call(expression),
-        ast::Expression::Value { value, binop } => {
+        ast::Expression::Value { value, binop, .. } => {
             if binop.is_none() {
                 if let ast::Value::Symbol(symbol) = &**value {
                     *symbol.token_type()