Hardening grammar

pom.xml

@@ -54,7 +54,7 @@
         <sonar.version>7.9</sonar.version>
         <java.version>8</java.version>
         <sslr.version>1.24.0.633</sslr.version>
-        <sslr-squid-bridge.version>2.7.0.377</sslr-squid-bridge.version>
+        <sslr-squid-bridge.version>2.7.1.392</sslr-squid-bridge.version>
         <mockito.version>3.6.28</mockito.version>
         <assertj-core.version>3.19.0</assertj-core.version>
         <jacoco.version>0.8.6</jacoco.version>

rust-frontend/src/test/java/org/sonar/rust/RustLexerTest.java

@@ -20,10 +20,15 @@
 package org.sonar.rust;
 
 import com.google.common.base.Charsets;
+import com.sonar.sslr.api.AstNode;
 import com.sonar.sslr.api.Token;
+import com.sonar.sslr.impl.ast.AstXmlPrinter;
 import org.junit.Test;
+import org.sonar.sslr.parser.LexerlessGrammar;
+import org.sonar.sslr.parser.ParserAdapter;
 import org.sonar.sslr.tests.Assertions;
 
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 
 import static org.fest.assertions.Assertions.assertThat;
@@ -59,4 +64,23 @@ public void testTokens() {
 
         ;
     }
+
+    @Test
+    public void testParsing() {
+
+
+        String sexpr = "#![feature(const_fn_fn_ptr_basics)]";
+
+
+        //Print out Ast node content for debugging purpose
+
+        ParserAdapter<LexerlessGrammar> parser = new ParserAdapter<>(StandardCharsets.UTF_8, RustGrammar.create().build());
+        AstNode rootNode = parser.parse(sexpr);
+        org.fest.assertions.Assertions.assertThat(rootNode.getType()).isSameAs(RustGrammar.COMPILATION_UNIT);
+        AstNode astNode = rootNode;
+        //org.fest.assertions.Assertions.assertThat(astNode.getNumberOfChildren()).isEqualTo(4);
+        System.out.println(AstXmlPrinter.print(astNode));
+
+
+    }
 }

rust-frontend/src/test/java/org/sonar/rust/parser/attributes/AttributeTest.java

@@ -43,6 +43,7 @@ public void testAttribute() {
     public void testInnerAttribute() {
         assertThat(RustGrammar.create().build().rule(RustGrammar.INNER_ATTRIBUTE))
                 .matches("#![crate_type = \"lib\"]")
+                .matches("#![feature(const_fn_fn_ptr_basics)]")
         ;
     }
 

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/BlockExpressionTest.java

@@ -40,18 +40,7 @@ public class BlockExpressionTest {
      */
 
 
-    @Test
-    public void testStatements() {
-        assertThat(RustGrammar.create().build().rule(RustGrammar.STATEMENTS))
-                .matches("println!(\"hi there\");")
-                .matches("println!(\"hi there\");\n" +
-                        "println!(\"how are you today ?\");")
 
-                .matches("j.set(i.get()); false")
-                .matches("j.set(i.get() + 1); false")
-                .matches("node_fetch::create_http_client(user_agent.clone(), my_data.clone()).unwrap()")
-                ;
-    }
 
     @Test
     public void testAsyncBlockExpression() {
@@ -65,6 +54,9 @@ public void testAsyncBlockExpression() {
     public void testBlockExpression() {
         assertThat(RustGrammar.create().build().rule(RustGrammar.BLOCK_EXPRESSION))
                 .matches("{}")
+                .matches("{\n" +
+                        "    // comment\n" +
+                        "}")
                 .matches("{let y=42;}")
                 .matches("{println!(\"hi there\");}")
                 .matches("{abc()}")
@@ -93,11 +85,9 @@ public void testBlockExpression() {
                 .matches("{\n" +
                         "        self.len() as u32\n" +
                         "    }")
-                /* FIXME
                 .matches("{\n" +
                         "    &[b' ', b' ', b' '][0..(4 - (len & 3)) & 3]\n" +
                         "}")
-                        */
 
                 .matches("{ Box::new(move |state : Rc<RefCell<OpState>>, bufs: BufVec| -> Op {\n" +
                         "        let mut b = 42;\n" +
@@ -106,7 +96,7 @@ public void testBlockExpression() {
                 .matches("{\n" +
                         "            PathBuf::from(\"/demo_dir/\")\n" +
                         "        }")
-                .matches("{PathBuf::from(r\"C:\\demo_dir\\\")}")
+                .matches("{PathBuf::from(r\"C:\\demodir\\\")}")
                 .matches("{\n" +
                         "            if check {\n" +
                         "                check_source_files(config, paths).res1;\n" +
@@ -115,6 +105,12 @@ public void testBlockExpression() {
                         "            }\n" +
                         "            Ok(())\n" +
                         "        }")
+                .matches("{\n" +
+                        "    JsError {}     \n" +
+                        "}")
+                .matches("{\n" +
+                        "  continue 'outer;\n" +
+                        "}")
 
 
 

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/CallExpressionTest.java

@@ -29,7 +29,7 @@ public class CallExpressionTest {
     @Test
     public void testCallParams() {
         assertThat(RustGrammar.create().build().rule(RustGrammar.CALL_PARAMS))
-                //.matches("")
+                .matches("..")
                 .matches("1i32")
                 .matches("{let y=42;}")
                 .matches("{;}")

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/ExpressionTest.java

@@ -26,7 +26,28 @@
 
 public class ExpressionTest {
 
+    @Test
+    public void testExpressionExceptStruct() {
+        assertThat(RustGrammar.create().build().rule(RustGrammar.EXPRESSION_EXCEPT_STRUCT))
+                .matches("a")
+                .matches("a || b")
+                .matches("a() || b")
+                .matches("a() || b()")
+                .matches("a || b && c")
+                .notMatches("my_struct{}")
+                .notMatches("my_struct{}.field")
+                .notMatches("a || not_struct {}")
+                .matches("matches.value_of(\"log-level\").unwrap()")
+                .matches("!a || b")
+                .matches("a || !b")
+                .matches("completions.is_empty() && !did_match")
+                .notMatches("completions.is_empty() && !did_match { None } ")
+                .matches("!c")
+                .notMatches("!c { None }")
+                .matches("continue 'outer")
 
+        ;
+    }
 
     @Test
     public void testExpression() {
@@ -85,6 +106,13 @@ public void testExpression() {
                         "            Ok(())\n" +
                         "        }\n" +
                         "            .boxed_local()")
+                .notMatches("is_ok {\n" +
+                "        // empty block" +
+                " } ")
+                .matches("..")
+                .matches("break 42")
+                .matches("break Ok(Poll::Pending)")
+
      ;
     }
 }

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/ExpressionWithBlockTest.java

@@ -39,6 +39,8 @@ public void testExpressionWithBlock() {
                 .matches("if run_coverage {\n" +
                         "        println!(\"Coverage is running\");" +
                         " } ")
+                .matches("async move {}")
+                .notMatches("async move {}.f()")
                 .matches("async move {\n" +
                         "            if check {\n" +
                         "                check_source_files(config, paths).await?;\n" +
@@ -47,6 +49,7 @@ public void testExpressionWithBlock() {
                         "            }\n" +
                         "            Ok(())\n" +
                         "        }")
+                .notMatches("async {}.inc()")
         ;
     }
 }

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/ExpressionWithoutBlockTest.java

@@ -29,10 +29,6 @@ public class ExpressionWithoutBlockTest {
     public void testExpressionWithoutBlock() {
         assertThat(RustGrammar.create().build().rule(RustGrammar.EXPRESSION_WITHOUT_BLOCK))
                 .notMatches("== b")
-                //TODO Litteral Expression
-                //TODO Path expression
-                //Operator expressdions
-                //borrow expr
                 .matches("&7")
                 .matches("& Value")
                 .matches("&mut array")
@@ -41,14 +37,14 @@ public void testExpressionWithoutBlock() {
                 .matches("&&&& mut 10")
                 .matches("&& && mut 10")
                 .matches("& & & & mut 10")
-                //deref
-                .matches("*thing")
-                //err propagation
-                .matches("foo?")
+
+                .matches("*thing") //deref
+
+                .matches("foo?")//err propagation
                 .matches("None?")
                 .matches("Some(42)?")
-                //negation expression
-                .matches("!foo")
+
+                .matches("!foo")//negation expression
                 .matches("-5")
                 .matches("-bar")
                 .notMatches("== b")
@@ -84,6 +80,7 @@ public void testExpressionWithoutBlock() {
                 //TODO   TupleExpression
                 //TODO   TupleIndexingExpression
                 //TODO   StructExpression
+                .matches("mystruct{}")
                 //TODO   EnumerationVariantExpression
                 //  CallExpression
 
@@ -94,13 +91,14 @@ public void testExpressionWithoutBlock() {
                 //MethodCallExpression
                 //
                 //
-
+                .matches("async move {}.local()")
                 .matches("\"123\".parse()")
                 .matches("node_fetch::create_http_client(user_agent.clone(), my_data.clone()).unwrap()")
                 //FieldExpression
                 .matches("other.major")
                 //TODO ClosureExpression
-                //TODO ContinueExpression
+                //ContinueExpression
+                .matches("continue 'outer")
                 //TODO BreakExpression
                 //TODO RangeExpression
                 //ReturnExpression
@@ -116,6 +114,14 @@ public void testExpressionWithoutBlock() {
                 .matches("Vec::new")
                 .matches("Identifier::Numeric")
                 .matches("&[b' ', b' ', b' '][0..(4 - (len & 3)) & 3]")
+                .matches("async move {}.await")
+                .matches("async move {}.local()")
+                .matches("async {}.inc()")
+
+                .matches("async move {}\n" +
+                        "           .boxed()")
+
+
         ;
     }
 }

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/IfExpressionTest.java

@@ -39,6 +39,20 @@ public void tesIfExpression() {
                 .matches("if run_coverage {\n" +
                         "        println!(\"Coverage is running\");" +
                         " } ")
+                .matches("if is_ok {} ")
+                .matches("if if_ok {} ")
+                .matches("if match_ok {} ")
+                .matches("if async_ok {} ")
+                .matches("if is_red || is_black {let cpt = 1 ;} else  {let cpt = 0 ;}")
+                .matches("if is_red || is_black {}")
+                .matches("if is_red || is_black {} else  {let cpt = 0 ;}")
+                .matches("if is_ok {\n" +
+                        "        // empty block\n" +
+                        " } ")
+                .matches("if is_ok {} else {let x = 42;}")
+                .matches("if is_ok {\n" +
+                        "        // empty block\n" +
+                        " } else {let x = 42;}")
                 .matches("if bytes.len() < 3 * 4 {\n" +
                         "        println!(\"Too short\");" +
                         "        }")
@@ -68,6 +82,38 @@ public void tesIfExpression() {
                         "                        }\n" +
                         "                    }\n" +
                         "                }")
+                .matches("if is_ok \n" +
+                        "            {} else {\n" +
+                        "                let msg = \"Module evaluation is still pending but there are no pending ops or dynamic imports. This situation is often caused by unresolved promise.\";\n" +
+                        "                return Poll::Ready(Err(generic_error(msg)));\n" +
+                        "            }")
+                .matches("if is_ops || has_pending_dyn_imports || has_pending_dyn_module_evaluation\n" +
+                        "            {} else {\n" +
+                        "                let msg = \"Module evaluation is still pending but there are no pending ops or dynamic imports. This situation is often caused by unresolved promise.\";\n" +
+                        "                return Poll::Ready(Err(generic_error(msg)));\n" +
+                        "            }")
+                .matches("if has_ops\n" +
+                        "                || has_pending_dyn_imports\n" +
+                        "                || has_pending_dyn_module_evaluation\n" +
+                        "            {} else {\n" +
+                        "                let msg = \"Module evaluation is still pending but there are no pending ops or dynamic imports. This situation is often caused by unresolved promise.\";\n" +
+                        "                return Poll::Ready(Err(generic_error(msg)));\n" +
+                        "            }")
+                .matches("if has_pending_ops\n" +
+                        "                || has_pending_dyn_imports\n" +
+                        "                || has_pending_dyn_module_evaluation\n" +
+                        "            {\n" +
+                        "                // pass, will be polled again\n" +
+                        "            } else {\n" +
+                        "                let msg = \"Module evaluation is still pending but there are no pending ops or dynamic imports. This situation is often caused by unresolved promise.\";\n" +
+                        "                return Poll::Ready(Err(generic_error(msg)));\n" +
+                        "            }")
+                .matches("if a && b { None }")
+                .matches("if !c { None }")
+                .matches("if a && !b { None }")
+                .matches("if state.get_state() == MyState::KO {\n" +
+                        "                continue 'outer;\n" +
+                        "            }")
 
 
         ;

rust-frontend/src/test/java/org/sonar/rust/parser/expressions/LoopExpressionTest.java

@@ -26,6 +26,26 @@
 
 public class LoopExpressionTest {
 
+    @Test
+    public void testBreakExpression() {
+        assertThat(RustGrammar.create().build().rule(RustGrammar.BREAK_EXPRESSION))
+                .matches("break")
+                .matches("break 42")
+                .matches("break foo")
+                .matches("break a.method()")
+                .matches("break 'a b.method()")
+                .matches("break Ok(Poll::Pending)")
+                ;
+    }
+
+    @Test
+    public void testContinueExpression() {
+        assertThat(RustGrammar.create().build().rule(RustGrammar.CONTINUE_EXPRESSION))
+                .matches("continue 'outer")
+
+        ;
+    }
+
     @Test
     public void testLoopExpression() {
         assertThat(RustGrammar.create().build().rule(RustGrammar.LOOP_EXPRESSION))
@@ -50,6 +70,10 @@ public void testLoopExpression() {
                 .matches("for n in 1..11 {\n" +
                         "    sum += n;\n" +
                         "}")
+                .matches("while i < j {\n" +
+                        "    println!(\"hello\");\n" +
+                        "    i = i + 1;\n" +
+                        "}")
         ;
     }
 }