Исправлено подключение нескольких модулей сразу

src/main/java/com/annimon/ownlang/parser/ast/UseStatement.java

@@ -50,18 +50,15 @@ public final class UseStatement extends InterruptableNode implements Statement {
     }
 
     public void loadConstants() {
-        final Value value = expression.eval();
+        if (expression instanceof ArrayExpression) {
-        switch (value.type()) {
+            ArrayExpression ae = (ArrayExpression) expression;
-            case Types.ARRAY:
+            for (Expression expr : ae.elements) {
-                for (Value module : ((ArrayValue) value)) {
+                loadConstants(expr.eval().asString());
-                    loadConstants(module.asString());
             }
-                break;
+        }
-            case Types.STRING:
+        if (expression instanceof ValueExpression) {
-                loadConstants(value.asString());
+            ValueExpression ve = (ValueExpression) expression;
-                break;
+            loadConstants(ve.value.asString());
-            default:
-                throw typeException(value);
         }
     }
 

src/main/java/com/annimon/ownlang/parser/linters/UseWithNonStringValueValidator.java

@@ -1,7 +1,6 @@
 package com.annimon.ownlang.parser.linters;
 
 import com.annimon.ownlang.Console;
-import com.annimon.ownlang.lib.ArrayValue;
 import com.annimon.ownlang.lib.Types;
 import com.annimon.ownlang.lib.Value;
 import com.annimon.ownlang.parser.ast.*;
@@ -17,28 +16,34 @@ public final class UseWithNonStringValueValidator extends LintVisitor {
     @Override
     public void visit(UseStatement st) {
         super.visit(st);
-        if (!(st.expression instanceof ValueExpression)) {
+
-            Console.error(String.format(
+        if (st.expression instanceof ArrayExpression) {
-                    "Warning: `use` with %s, not ValueExpression", st.expression.getClass().getSimpleName()));
+            ArrayExpression ae = (ArrayExpression) st.expression;
+            for (Expression expr : ae.elements) {
+                if (!checkExpression(expr)) {
                     return;
                 }
+            }
+        } else {
+            if (!checkExpression(st.expression)) {
+                return;
+            }
+        }
+    }
 
-        final Value value = ((ValueExpression) st.expression).value;
+    private boolean checkExpression(Expression expr) {
-        switch (value.type()) {
+        if (!(expr instanceof ValueExpression)) {
-            case Types.STRING:
+            Console.error(String.format(
-                // ok
+                    "Warning: `use` with %s, not ValueExpression", expr.getClass().getSimpleName()));
-                break;
+            return false;
-            case Types.ARRAY:
-                // ok, need additional check
-                for (Value module : ((ArrayValue) value)) {
-                    if (module.type() != Types.STRING) {
-                        warnWrongType(module);
         }
-                }
+
-                break;
+        final Value value = ((ValueExpression) expr).value;
-            default:
+        if (value.type() != Types.STRING) {
             warnWrongType(value);
+            return false;
         }
+        return true;
     }
 
     private void warnWrongType(Value value) {

src/main/java/com/annimon/ownlang/parser/optimization/VariablesGrabber.java

@@ -2,20 +2,7 @@ package com.annimon.ownlang.parser.optimization;
 
 import com.annimon.ownlang.lib.Value;
 import com.annimon.ownlang.lib.Variables;
-import com.annimon.ownlang.parser.ast.Accessible;
+import com.annimon.ownlang.parser.ast.*;
-import com.annimon.ownlang.parser.ast.Argument;
-import com.annimon.ownlang.parser.ast.Arguments;
-import com.annimon.ownlang.parser.ast.AssignmentExpression;
-import com.annimon.ownlang.parser.ast.ContainerAccessExpression;
-import com.annimon.ownlang.parser.ast.DestructuringAssignmentStatement;
-import com.annimon.ownlang.parser.ast.ForeachArrayStatement;
-import com.annimon.ownlang.parser.ast.ForeachMapStatement;
-import com.annimon.ownlang.parser.ast.MatchExpression;
-import com.annimon.ownlang.parser.ast.Node;
-import com.annimon.ownlang.parser.ast.UnaryExpression;
-import com.annimon.ownlang.parser.ast.UseStatement;
-import com.annimon.ownlang.parser.ast.ValueExpression;
-import com.annimon.ownlang.parser.ast.VariableExpression;
 import static com.annimon.ownlang.parser.visitors.VisitorUtils.isValue;
 import static com.annimon.ownlang.parser.visitors.VisitorUtils.isVariable;
 import java.util.HashMap;
@@ -116,7 +103,7 @@ public class VariablesGrabber extends OptimizationVisitor<Map<String, VariableIn
             // To get module variables we need  to store current variables, clear all, then load module.
             final Map<String, Value> currentVariables = new HashMap<>(Variables.variables());
             Variables.variables().clear();
-            if (isValue(s.expression)) {
+            if (canLoadConstants(s.expression)) {
                 s.loadConstants();
             }
             // Grab module variables
@@ -131,6 +118,19 @@ public class VariablesGrabber extends OptimizationVisitor<Map<String, VariableIn
         return super.visit(s, t);
     }
 
+    private boolean canLoadConstants(Expression expression) {
+        if (expression instanceof ArrayExpression) {
+            ArrayExpression ae = (ArrayExpression) expression;
+            for (Expression expr : ae.elements) {
+                if (!isValue(expr)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return isValue(expression);
+    }
+
     @Override
     protected boolean visit(Arguments in, Arguments out, Map<String, VariableInfo> t) {
         for (Argument argument : in) {

src/main/java/com/annimon/ownlang/parser/visitors/ModuleDetector.java

@@ -1,8 +1,7 @@
 package com.annimon.ownlang.parser.visitors;
 
-import com.annimon.ownlang.lib.ArrayValue;
+import com.annimon.ownlang.parser.ast.ArrayExpression;
-import com.annimon.ownlang.lib.Types;
+import com.annimon.ownlang.parser.ast.Expression;
-import com.annimon.ownlang.lib.Value;
 import com.annimon.ownlang.parser.ast.Statement;
 import com.annimon.ownlang.parser.ast.UseStatement;
 import com.annimon.ownlang.parser.ast.ValueExpression;
@@ -24,16 +23,16 @@ public class ModuleDetector extends AbstractVisitor {
 
     @Override
     public void visit(UseStatement st) {
+        if (st.expression instanceof ArrayExpression) {
+            ArrayExpression ae = (ArrayExpression) st.expression;
+            for (Expression expr : ae.elements) {
+                modules.add(expr.eval().asString());
+            }
+        }
         if (st.expression instanceof ValueExpression) {
             ValueExpression ve = (ValueExpression) st.expression;
-            if (ve.value.type() == Types.ARRAY) {
-                for (Value module : ((ArrayValue) ve.value)) {
-                    modules.add(module.asString());
-                }
-            } else {
             modules.add(ve.value.asString());
         }
-        }
         super.visit(st);
     }
 }