Implement out_array hard coding

Author: MightyHelper

.idea/workspace.xml

@@ -23,7 +23,7 @@ public class ClassEntry implements Scope {
 	public TypeEntry superClass = null;
 	public boolean isConsolidated = false;
 	private final TinyRustSymbolTable root;
-	private ClassEntry superClassLink;
+	protected ClassEntry superClassLink;
 	@SerializeClass({TS, AST}) public TinyRustLexerToken name;
 	@SerializeClass(TS) public final boolean isExtendable;
 	@SerializeClass(TS) public final boolean isArrayValid;
@@ -219,21 +219,21 @@ private void checkIfMethodNameClash(TinyRustLexerToken name) {
 			throw new MethodRedeclaredError(name.location(), "Method " + name.lexeme() + " already exists in class");
 	}
 
-	private void consolidateFields() {
+	protected void consolidateFields() {
 		List<VariableEntry> allFields = Utils.concat(superClassLink.fields, fields);
 		IntStream.range(0, fields.size()).forEach(i -> fields.get(i).index = superClassLink.fields.size() + i); // Set index of fields
 		List<VariableEntry> repeatedFields = Utils.getRepeatedAttributeNames(allFields);
 		if (!repeatedFields.isEmpty()) throw new FieldRedeclaredError(repeatedFields);
 		fields.forEach(VariableEntry::consolidate);
 	}
 
-	private void consolidateMethods() {
+	protected void consolidateMethods() {
 		checkDuplicateMethodNames();
 		checkOverwriting();
 		methods.forEach(MethodEntry::consolidate);
 	}
 
-	private void checkOverwriting() {
+	protected void checkOverwriting() {
 		List<MethodEntry> overrideCandidates = getOverrideCandidates();
 		overrideCandidates.forEach(this::overrideMethod);
 		List<MethodEntry> notOverwrittenMethods = Utils.minus(methods, overrideCandidates, method -> method.name.lexeme());
@@ -268,7 +268,7 @@ private Set<MethodEntry> getAllMethods() {
 		return Stream.concat(superClassLink.getAllMethods().stream(), methods.stream()).collect(Collectors.toSet());
 	}
 
-	private void checkDuplicateMethodNames() {
+	protected void checkDuplicateMethodNames() {
 		List<MethodEntry> repeated = Utils.getRepeatedAttributeNames(methods);
 		if (!repeated.isEmpty())
 			throw new MethodRedeclaredError(repeated.get(0).name.location(), "Method " + repeated.get(0).name.lexeme() + " already exists in class");

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ts/ClassEntry.java

@@ -9,6 +9,8 @@
 import java.util.List;
 
 public class IOClassEntry extends ClassEntry {
+	private final OutArrayMethodEntry outArrayMethod;
+
 	public IOClassEntry(TinyRustSymbolTable root) {
 		super(root, new TinyRustLexerToken(TinyRustTokenType.CLASS_ID, "IO"), true, false);
 //		static fn out string(Str: s)->void: imprime el argumento.
@@ -25,13 +27,23 @@ public IOClassEntry(TinyRustSymbolTable root) {
 		createMethod(root, "out_i32", TypeEntry.VOID, "out_i32", TypeEntry.I32);
 		createMethod(root, "out_bool", TypeEntry.VOID, "out_bool", TypeEntry.BOOL);
 		createMethod(root, "out_char", TypeEntry.VOID, "out_char", TypeEntry.CHAR);
-//		createMethod(root, "out_array", TypeEntry.VOID, "out_array", TypeEntry.ARRAY);
+		outArrayMethod = new OutArrayMethodEntry(root, this);
+		addMethod(outArrayMethod);
 		createMethod(root, "in_str", TypeEntry.STR);
 		createMethod(root, "in_i32", TypeEntry.I32);
 		createMethod(root, "in_bool", TypeEntry.BOOL);
 		createMethod(root, "in_char", TypeEntry.CHAR);
 	}
 
+	@Override
+	protected void consolidateMethods() {
+		checkDuplicateMethodNames();
+		checkOverwriting();
+		methods.stream().filter(it->!it.equals(outArrayMethod)).forEach(MethodEntry::consolidate);
+	}
+
+
+
 	private void createMethod(TinyRustSymbolTable root, String name, TypeEntry ret) {
 		MethodEntry m = new MethodEntry(
 			root,

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ts/IOClassEntry.java

@@ -20,7 +20,7 @@
 import static ko.carbonel.json.SerializeClass.AST;
 import static ko.carbonel.json.SerializeClass.TS;
 
-public final class MethodEntry extends AttributeEntry implements Scope {
+public class MethodEntry extends AttributeEntry implements Scope {
 	public static final String CONSTRUCTOR = "create";
 	private final TinyRustSymbolTable root;
 	private Scope parentScope;

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ts/MethodEntry.java

@@ -0,0 +1,43 @@
+package ko.carbonel.compiler.intermediate.tinyRust.ts;
+
+import ko.carbonel.compiler.exception.semantic.IncompatibleTypesError;
+import ko.carbonel.compiler.exception.semantic.WrongNumberOfArgumentsError;
+import ko.carbonel.compiler.intermediate.tinyRust.TinyRustSymbolTable;
+import ko.carbonel.compiler.intermediate.tinyRust.ast.expression.ExpressionEntry;
+import ko.carbonel.compiler.intermediate.tinyRust.ast.statement.BlockStatementEntry;
+import ko.carbonel.compiler.stream.lexer.tinyRust.model.TinyRustLexerToken;
+import ko.carbonel.compiler.stream.reader.FileLocation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Special method for outputting an array of any type to the console.
+ */
+public class OutArrayMethodEntry extends MethodEntry {
+	public OutArrayMethodEntry(TinyRustSymbolTable root, Scope parentScope) {
+		super(root, parentScope);
+		this.parameters = List.of(new VariableEntry(root, TinyRustLexerToken.attr("arr"), TypeEntry.ARRAY, false));
+		this.returnType = TypeEntry.VOID;
+		this.name = TinyRustLexerToken.attr("out_array");
+		this.block = new BlockStatementEntry();
+		this.block.statements = new ArrayList<>();
+	}
+
+	/**
+	 * Verifies that the arguments are valid for this method. Custom array only check
+	 * @param arguments The incoming arguments
+	 * @param scope The scope to use for type checking
+	 * @param location The location of the method call
+	 */
+	@Override
+	public void verifyArguments(List<ExpressionEntry> arguments, Scope scope, FileLocation location) {
+		if (arguments.size() != 1) {
+			throw new WrongNumberOfArgumentsError(location, "Expected 1 argument, got " + arguments.size());
+		}
+		TypeEntry arg0Type = arguments.get(0).getType(scope, false);
+		if (!arg0Type.isArray) {
+			throw new IncompatibleTypesError(location, "Expected array argument, got " + arg0Type);
+		}
+	}
+}

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ts/OutArrayMethodEntry.java

@@ -19,6 +19,7 @@ public class TypeEntry {
 	public static final TypeEntry VOID = of(new TinyRustLexerToken(TinyRustTokenType.VOID, "void"));
 	public static final TypeEntry BOOL = of(new TinyRustLexerToken(TinyRustTokenType.BOOL, "Bool"));
 	public static final TypeEntry CHAR = of(new TinyRustLexerToken(TinyRustTokenType.CHR, "Char"));
+	public static final TypeEntry ARRAY = new TypeEntry(new TinyRustLexerToken(TinyRustTokenType.ARRAY, "Array"), true);
 	private ClassEntry classLink;
 	@SerializeClass(TS)
 	public final TinyRustLexerToken type;

src/main/java/ko/carbonel/compiler/intermediate/tinyRust/ts/TypeEntry.java

@@ -0,0 +1,8 @@
+/*OK
+*/
+fn main(){
+    (IO.out_array(new I32[5+2]));
+    (IO.out_array(new Str[1]));
+    (IO.out_array(new Char[0]));
+    (IO.out_array(new Bool[0]));
+}

src/test/resources/ast/20.rs

@@ -0,0 +1,8 @@
+/*OK
+*/
+fn main(){
+    (IO.out_array(new I32[(5+2)]));
+    (IO.out_array(new Str[1]));
+    (IO.out_array(new Char[0]));
+    (IO.out_array(new Bool[0]));
+}

src/test/resources/ast/20.rs.full

@@ -0,0 +1,6 @@
+/*ERROR
+IncompatibleTypesError
+*/
+fn main(){
+    (IO.out_array(5));
+}

src/test/resources/ast/21.rs

@@ -0,0 +1,6 @@
+/*ERROR
+IncompatibleTypesError
+*/
+fn main(){
+    (IO.out_array("Hi there"));
+}