Add internal soft keyword as simple identifier

Author: punchagan

grammar.js

@@ -72,6 +72,8 @@ module.exports = grammar({
     [$.platform_modifier, $.simple_identifier],
     // "data", "inner" as class modifier or id
     [$.class_modifier, $.simple_identifier],
+    // "internal" as visibility modifier conflicts with internal as an identifier
+    [$.visibility_modifier, $.simple_identifier],
 
     // "<x>.<y> = z assignment conflicts with <x>.<y>() function call"
     [$._postfix_unary_expression, $._expression],
@@ -1110,6 +1112,7 @@ module.exports = grammar({
       "get",
       "enum",
       "annotation",
+      "internal",
       // TODO: More soft keywords
     ),
 

test/corpus/classes.txt

@@ -4,6 +4,7 @@ Classes
 
 class Empty
 class Empty2 {}
+internal class Empty3 {}
 
 --------------------------------------------------------------------------------
 
@@ -12,6 +13,11 @@ class Empty2 {}
     (type_identifier))
   (class_declaration
     (type_identifier)
+    (class_body))
+  (class_declaration
+    (modifiers
+      (visibility_modifier))
+    (type_identifier)
     (class_body)))
 
 ================================================================================
@@ -401,11 +407,23 @@ interface Foo {
     fun bar()
 }
 
+internal interface Bar {
+    fun foo()
+}
+
 --------------------------------------------------------------------------------
 
 (source_file
   (class_declaration
     (type_identifier)
+    (class_body
+      (function_declaration
+        (simple_identifier)
+        (function_value_parameters))))
+  (class_declaration
+    (modifiers
+      (visibility_modifier))
+    (type_identifier)
     (class_body
       (function_declaration
         (simple_identifier)

test/corpus/expressions.txt

@@ -328,6 +328,8 @@ foo.forEach { (index, value) -> 2 }
 
 annotations.filter { annotation -> true }
 
+availability.associate { internal -> false }.toMap()
+
 --------------------------------------------------------------------------------
 
 (source_file
@@ -359,7 +361,26 @@ annotations.filter { annotation -> true }
             (variable_declaration
               (simple_identifier)))
           (statements
-            (boolean_literal)))))))
+            (boolean_literal))))))
+  (call_expression
+    (navigation_expression
+      (call_expression
+        (navigation_expression
+          (simple_identifier)
+          (navigation_suffix
+            (simple_identifier)))
+        (call_suffix
+          (annotated_lambda
+            (lambda_literal
+              (lambda_parameters
+                (variable_declaration
+                  (simple_identifier)))
+              (statements
+                (boolean_literal))))))
+      (navigation_suffix
+        (simple_identifier)))
+    (call_suffix
+      (value_arguments))))
 
 ================================================================================
 Function call with trailing lambda