i22006/Compilerbau2024AbsolutNichtHaskell
i22006/Compilerbau2024AbsolutNichtHaskell
2
0
Fork 0
mirror of https://github.com/JonathanFleischmann/CompilerULTIMATE.git synced 2024-12-28 17:28:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

adapted testfiles to new ast and commented code with issues out

Browse Source
This commit is contained in:
JonathanFleischmann 2024-05-08 11:11:51 +02:00
parent 98d899e026
commit 9730455b50
18 changed files with 751 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructor.java
View File

@ -29,7 +29,6 @@ public class AbstractSyntax_ClassWithConstructor {
List<Method> methods = List.of(); List<Method> methods = List.of();
List<Constructor> constructors = getConstructors(); List<Constructor> constructors = getConstructors();
return new Class( return new Class(
true,
new Id("ClassWithConstructor"), new Id("ClassWithConstructor"),
fields, fields,
methods, methods,

2
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorAndMethodCall.java
View File

@ -38,7 +38,6 @@ public class AbstractSyntax_ClassWithConstructorAndMethodCall {
List<Method> methodList = getMethods(); List<Method> methodList = getMethods();
List<Constructor> constructorList = getConstructors(); List<Constructor> constructorList = getConstructors();
return new Class( return new Class(
true,
new Id("ClassWithConstructorAndMethodCall"), new Id("ClassWithConstructorAndMethodCall"),
fieldList, fieldList,
methodList, methodList,
@ -98,7 +97,6 @@ public class AbstractSyntax_ClassWithConstructorAndMethodCall {
private static Method getMethod1() { private static Method getMethod1() {
return new Method( return new Method(
true,
ReturnType.BOOL, ReturnType.BOOL,
new Id("methodCall"), new Id("methodCall"),
List.of(), List.of(),

1
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithConstructorWithParameters.java
View File

@ -31,7 +31,6 @@ public class AbstractSyntax_ClassWithConstructorWithParameters {
); );
List<Constructor> constructors = getConstructors(); List<Constructor> constructors = getConstructors();
return new Class( return new Class(
true,
new Id("ClassWithConstructorWithParameters"), new Id("ClassWithConstructorWithParameters"),
fields, fields,
List.of(), List.of(),

1
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithField.java
View File

@ -22,7 +22,6 @@ public class AbstractSyntax_ClassWithField {
List<Method> methods = List.of(); List<Method> methods = List.of();
List<Constructor> constructors = List.of(); List<Constructor> constructors = List.of();
return new Class( return new Class(
true,
new Id("ClassWithAssignment"), new Id("ClassWithAssignment"),
fields, fields,
methods, methods,

2
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethod.java
View File

@ -14,7 +14,6 @@ public class AbstractSyntax_ClassWithMethod {
public static Class get() { public static Class get() {
List<Method> methods = getMethods(); List<Method> methods = getMethods();
return new Class( return new Class(
true,
new Id("ClassWithMethod"), new Id("ClassWithMethod"),
List.of(), List.of(),
methods, methods,
@ -29,7 +28,6 @@ public class AbstractSyntax_ClassWithMethod {
private static Method getMethod1() { private static Method getMethod1() {
return new Method( return new Method(
true,
ReturnType.BOOL, ReturnType.BOOL,
new Id("method"), new Id("method"),
List.of(), List.of(),

2
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMethodAndField.java
View File

@ -27,7 +27,6 @@ class AbstractSyntax_ClassWithMethodAndField {
List<Method> methods = getMethods(); List<Method> methods = getMethods();
List<Constructor> constructors = getConstructors(); List<Constructor> constructors = getConstructors();
return new Class( return new Class(
false,
new Id("ClassWithMethodAndField"), new Id("ClassWithMethodAndField"),
fields, fields,
methods, methods,
@ -69,7 +68,6 @@ class AbstractSyntax_ClassWithMethodAndField {
private static Method getMethod1() { private static Method getMethod1() {
return new Method( return new Method(
true,
ReturnType.BOOL, ReturnType.BOOL,
new Id("method"), new Id("method"),
List.of(), List.of(),

2
src/main/resources/AbstractSyntax/AbstractSyntax_ClassWithMoreComplexMethodAndMain.java
View File

@ -37,7 +37,6 @@ public class AbstractSyntax_ClassWithMoreComplexMethodAndMain {
List<Method> methods = getMethods(); List<Method> methods = getMethods();
List<Constructor> constructors = List.of(); List<Constructor> constructors = List.of();
return new Class( return new Class(
true,
new Id("ClassWithMoreComplexMethodAndMain"), new Id("ClassWithMoreComplexMethodAndMain"),
fields, fields,
methods, methods,
@ -104,7 +103,6 @@ public class AbstractSyntax_ClassWithMoreComplexMethodAndMain {
) )
); );
return new Method( return new Method(
true,
ReturnType.BOOL, ReturnType.BOOL,
new Id("moreComplexMethod"), new Id("moreComplexMethod"),
List.of(), List.of(),

1
src/main/resources/AbstractSyntax/AbstractSyntax_OnlyClass.java
View File

@ -9,7 +9,6 @@ import java.util.List;
public class AbstractSyntax_OnlyClass { public class AbstractSyntax_OnlyClass {
public static Class get() { public static Class get() {
return new Class( return new Class(
false,
new Id("OnlyClass"), new Id("OnlyClass"),
List.of(), List.of(),
List.of(), List.of(),

1
src/main/resources/AbstractSyntax/AbstractSyntax_PublicClass.java
View File

@ -9,7 +9,6 @@ import java.util.List;
public class AbstractSyntax_PublicClass { public class AbstractSyntax_PublicClass {
public static Class get() { public static Class get() {
return new Class( return new Class(
true,
new Id("PublicClass"), new Id("PublicClass"),
List.of(), List.of(),
List.of(), List.of(),

154
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructor.java Normal file
View File

@ -0,0 +1,154 @@
//public class ClassWithConstructor {
// int x;
// public classWithConstructor() {
// this.x = 10;
// int i;
// for (i = 0; i < 6; i = i + 1) {
// int j;
// for (j = 0; j < this.x; j += 1) {
// this.x = this.x * this.x;
// }
// }
// }
//}
import de.maishai.ast.AssignSign;
import de.maishai.ast.Operator;
import de.maishai.typedast.Type;
import de.maishai.typedast.typedclass.*;
import java.util.List;
public class TypedAbstractSyntax_ClassWithConstructor {
public static TypedClass get() {
TypedClass typedClass = new TypedClass();
typedClass.setIsPublic(true);
typedClass.setTypedId(new TypedId("ClassWithConstructor"));
TypedField typedField = new TypedField();
typedField.setTypedId(new TypedId("x"));
typedField.setType(Type.INT);
typedClass.setTypedFields(List.of(typedField));
typedClass.setTypedMethods(List.of());
typedClass.setTypedMainMethod(null);
typedClass.setTypedConstructors(getConstructors());
return typedClass;
}
private static List<TypedConstructor> getConstructors() {
return List.of(getConstructor1());
}
private static TypedConstructor getConstructor1() {
TypedConstructor typedConstructor = new TypedConstructor();
typedConstructor.setIsPublic(true);
typedConstructor.setTypedId(new TypedId("ClassWithConstructor"));
typedConstructor.setTypedParameters(List.of());
TypedBlock typedBlock = new TypedBlock();
TypedLocalVariable typedLocalVariable = new TypedLocalVariable();
typedLocalVariable.setTypedId(new TypedId("i"));
typedLocalVariable.setType(Type.INT);
typedBlock.setVars(List.of(typedLocalVariable));
TypedAssignment typedAssignment = new TypedAssignment();
typedAssignment.setLoc(new TypedId("x"));
typedAssignment.setAssignSign(AssignSign.ASSIGN);
typedAssignment.setValue(new TypedIntLiteral(10));
TypedFor typedFor = new TypedFor();
TypedAssignment typedAssignmentFor = new TypedAssignment();
typedAssignmentFor.setLoc(new TypedId("i"));
typedAssignmentFor.setAssignSign(AssignSign.ASSIGN);
typedAssignmentFor.setValue(new TypedIntLiteral(0));
// typedFor.setAssign(typedAssignmentFor);
TypedBinary typedBinaryFor = new TypedBinary();
typedBinaryFor.setLeft(new TypedId("i"));
typedBinaryFor.setOp(Operator.LT);
typedBinaryFor.setRight(new TypedIntLiteral(6));
typedFor.setCond(typedBinaryFor);
TypedBinary typedBinaryForIncr = new TypedBinary();
typedBinaryForIncr.setLeft(new TypedId("i"));
typedBinaryForIncr.setOp(Operator.ADD);
typedBinaryForIncr.setRight(new TypedIntLiteral(1));
TypedAssignment typedAssignmentForIncr = new TypedAssignment();
typedAssignmentForIncr.setLoc(new TypedId("i"));
typedAssignmentForIncr.setAssignSign(AssignSign.ASSIGN);
typedAssignmentForIncr.setValue(typedBinaryForIncr);
// typedFor.setInc(typedAssignmentForIncr);
TypedBlock typedBlockFor = new TypedBlock();
TypedLocalVariable typedLocalVariableFor = new TypedLocalVariable();
typedLocalVariableFor.setTypedId(new TypedId("j"));
typedLocalVariableFor.setType(Type.INT);
typedBlockFor.setVars(List.of(typedLocalVariableFor));
TypedFor typedInnerFor = new TypedFor();
TypedAssignment typedAssignmentInnerFor = new TypedAssignment();
typedAssignmentInnerFor.setLoc(new TypedId("j"));
typedAssignmentInnerFor.setAssignSign(AssignSign.ASSIGN);
typedAssignmentInnerFor.setValue(new TypedIntLiteral(0));
// typedInnerFor.setAssign(typedAssignmentInnerFor);
TypedBinary typedBinaryInnerFor = new TypedBinary();
typedBinaryInnerFor.setLeft(new TypedId("j"));
typedBinaryInnerFor.setOp(Operator.LT);
typedBinaryInnerFor.setRight(new TypedId("x"));
typedInnerFor.setCond(typedBinaryInnerFor);
TypedAssignment typedAssignmentInnerForIncr = new TypedAssignment();
typedAssignmentInnerForIncr.setLoc(new TypedId("j"));
typedAssignmentInnerForIncr.setAssignSign(AssignSign.ADD_ASSIGN);
typedAssignmentInnerForIncr.setValue(new TypedIntLiteral(1));
// typedInnerFor.setInc(typedAssignmentInnerForIncr);
TypedBlock typedBlockInnerFor = new TypedBlock();
typedBlockInnerFor.setVars(List.of());
TypedAssignment typedAssignmentInnerForBlock = new TypedAssignment();
typedAssignmentInnerForBlock.setLoc(new TypedId("x"));
typedAssignmentInnerForBlock.setAssignSign(AssignSign.ASSIGN);
TypedBinary typedBinaryInnerForBlock = new TypedBinary();
typedBinaryInnerForBlock.setLeft(new TypedId("x"));
typedBinaryInnerForBlock.setOp(Operator.MUL);
typedBinaryInnerForBlock.setRight(new TypedId("x"));
typedAssignmentInnerForBlock.setValue(typedBinaryInnerForBlock);
typedBlockInnerFor.setStmts(List.of(typedAssignmentInnerForBlock));
typedInnerFor.setTypedBlock(typedBlockInnerFor);
typedBlockFor.setStmts(List.of(typedInnerFor));
typedFor.setTypedBlock(typedBlockFor);
typedBlock.setStmts(
List.of(
typedAssignment,
typedFor
)
);
typedConstructor.setTypedBlock(typedBlock);
return typedConstructor;
}
}

134
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructorAndMethodCall.java Normal file
View File

@ -0,0 +1,134 @@
//public class ClassWithConstructorAndMethodCall {
// int x;
//
// public ClassWithConstructorAndMethodCall() {
// this.x = 10;
// while (methodCall()) {
// this.x = this.x * this.x;
// }
// }
//
// public boolean methodCall() {
// if (this.x > 100) {
// return false;
// } else {
// return true;
// }
// }
//}
import de.maishai.ast.AssignSign;
import de.maishai.ast.Operator;
import de.maishai.ast.ReturnType;
import de.maishai.ast.Type;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class TypedAbstractSyntax_ClassWithConstructorAndMethodCall {
// public static Class get() {
// List<Field> fieldList = List.of(
// new Field(
// new Id("x"),
// Type.INT
// )
// );
// List<Method> methodList = getMethods();
// List<Constructor> constructorList = getConstructors();
// return new Class(
// new Id("ClassWithConstructorAndMethodCall"),
// fieldList,
// methodList,
// null,
// constructorList
// );
// }
//
// private static List<Constructor> getConstructors() {
// return List.of(getConstructor1());
// }
//
// private static Constructor getConstructor1() {
// Block block = new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("x"),
// AssignSign.ASSIGN,
// new IntLiteral(10)
// ),
// new While(
// new MethodCall(
// false,
// null,
// new Id("methodCall"),
// List.of()
// ),
// new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("x"),
// AssignSign.ASSIGN,
// new Binary(
// new Id("x"),
// Operator.MUL,
// new Id("x")
// )
// )
// )
// )
// )
// )
// );
// return new Constructor(
// true,
// new Id("ClassWithConstructorAndMethodCall"),
// List.of(),
// block
// );
// }
//
// private static List<Method> getMethods() {
// return List.of(getMethod1());
// }
//
// private static Method getMethod1() {
// return new Method(
// true,
// ReturnType.BOOL,
// new Id("methodCall"),
// List.of(),
// new Block(
// List.of(),
// List.of(
// new IfElse(
// new Binary(
// new Id("x"),
// Operator.GT,
// new IntLiteral(100)
// ),
// new Block(
// List.of(),
// List.of(
// new Return(
// new BoolLiteral(false)
// )
// )
// ),
// new Block(
// List.of(),
// List.of(
// new Return(
// new BoolLiteral(true)
// )
// )
// )
// )
// )
// )
// );
// }
}

130
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithConstructorWithParameters.java Normal file
View File

@ -0,0 +1,130 @@
//public class ClassWithConstructorWithParameters {
// int x;
// public classWithConstructorWithParameters(int startValue, int repetitions) {
// this.x = startValue;
// while (repetitions > 0) {
// int innerRepetitions;
// innerRepetitions = this.x;
// while (innerRepetitions > 0) {
// this.x = this.x * this.x;
// innerRepetitions -= 1;
// }
// repetitions -= 1;
// }
// }
//}
import de.maishai.ast.AssignSign;
import de.maishai.ast.Operator;
import de.maishai.ast.records.*;
import de.maishai.ast.Type;
import de.maishai.ast.records.Class;
import java.util.List;
public class TypedAbstractSyntax_ClassWithConstructorWithParameters {
// public static Class get() {
// List<Field> fields = List.of(
// new Field(
// new Id("x"),
// Type.INT
// )
// );
// List<Constructor> constructors = getConstructors();
// return new Class(
// true,
// new Id("ClassWithConstructorWithParameters"),
// fields,
// List.of(),
// null,
// constructors
// );
// }
//
// private static List<Constructor> getConstructors() {
// return List.of(getConstructor1());
// }
//
// private static Constructor getConstructor1() {
// List<Parameter> parameters = List.of(
// new Parameter(
// "startValue",
// Type.INT
// ),
// new Parameter(
// "repetitions",
// Type.INT
// )
// );
// Block block = new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("x"),
// AssignSign.ASSIGN,
// new Id("startValue")
// ),
// new While(
// new Binary(
// new Id("repetitions"),
// Operator.GT,
// new IntLiteral(0)
// ),
// new Block(
// List.of(
// new LocalVariable(
// new Id("innerRepetitions"),
// Type.INT
// )
// ),
// List.of(
// new Assignment(
// new Id("innerRepetitions"),
// AssignSign.ASSIGN,
// new Id("x")
// ),
// new While(
// new Binary(
// new Id("repetitions"),
// Operator.GT,
// new IntLiteral(0)
// ),
// new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("x"),
// AssignSign.ASSIGN,
// new Binary(
// new Id("x"),
// Operator.MUL,
// new Id("x")
// )
// ),
// new Assignment(
// new Id("innerRepetitions"),
// AssignSign.SUB_ASSIGN,
// new IntLiteral(1)
// )
// )
// )
// ),
// new Assignment(
// new Id("repetitions"),
// AssignSign.SUB_ASSIGN,
// new IntLiteral(1)
//
// )
// )
// )
// )
// )
// );
// return new Constructor(
// true,
// new Id("classWithConstructorWithParameters"),
// parameters,
// block
// );
// }
}

26
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithField.java Normal file
View File

@ -0,0 +1,26 @@
//public class ClassWithField {
// int x;
//}
import de.maishai.typedast.Type;
import de.maishai.typedast.typedclass.*;
import java.util.List;
public class TypedAbstractSyntax_ClassWithField {
public static TypedClass get() {
TypedClass typedClass = new TypedClass();
typedClass.setIsPublic(true);
typedClass.setTypedId(new TypedId("ClassWithField"));
typedClass.setTypedFields(
List.of(
new TypedField(new TypedId("x"), Type.INT)
)
);
typedClass.setTypedMethods(List.of());
typedClass.setTypedMainMethod(null);
typedClass.setTypedConstructors(List.of());
return typedClass;
}
}

46
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMethod.java Normal file
View File

@ -0,0 +1,46 @@
//public class ClassWithMethod {
// public boolean method() {
// return false;
// }
//}
import de.maishai.typedast.Type;
import de.maishai.typedast.typedclass.*;
import java.util.List;
public class TypedAbstractSyntax_ClassWithMethod {
public static TypedClass get() {
TypedClass typedClass = new TypedClass();
typedClass.setIsPublic(true);
typedClass.setTypedId(new TypedId("ClassWithMethod"));
typedClass.setTypedFields(List.of());
typedClass.setTypedMethods(getMethods());
return typedClass;
}
private static List<TypedMethod> getMethods() {
return List.of(getMethod1());
}
private static TypedMethod getMethod1() {
TypedMethod typedMethod = new TypedMethod();
typedMethod.setIsPublic(true);
typedMethod.setTypedId(new TypedId("method"));
typedMethod.setReturnType(Type.BOOL);
typedMethod.setTypedParameters(List.of());
TypedBoolLiteral typedBoolLiteral = new TypedBoolLiteral();
typedBoolLiteral.setValue(false);
TypedReturn typedReturn = new TypedReturn();
typedReturn.setRet(typedBoolLiteral);
TypedBlock typedBlock = new TypedBlock();
typedBlock.setVars(List.of());
typedBlock.setStmts(List.of(typedReturn));
typedMethod.setTypedBlock(typedBlock);
return typedMethod;
}
}

86
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMethodAndField.java Normal file
View File

@ -0,0 +1,86 @@
//public class ClassWithMethodAndField {
// char c;
//
// public ClassWithMethodAndField(char character) {
// this.c = character;
// }
//
// public boolean method() {
// return true;
// }
//}
import de.maishai.ast.*;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
class TypedAbstractSyntax_ClassWithMethodAndField {
// public static Class get() {
// List<Field> fields = List.of(
// new Field(
// new Id("c"),
// Type.CHAR
// )
// );
// List<Method> methods = getMethods();
// List<Constructor> constructors = getConstructors();
// return new Class(
// false,
// new Id("ClassWithMethodAndField"),
// fields,
// methods,
// null,
// constructors
// );
// }
//
// private static List<Constructor> getConstructors() {
// return List.of(getConstructor1());
// }
//
// private static Constructor getConstructor1() {
// return new Constructor(
// true,
// new Id("ClassWithMethodAndField"),
// List.of(
// new Parameter(
// "character",
// Type.CHAR
// )
// ),
// new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("c"),
// AssignSign.ASSIGN,
// new Id("character")
// )
// )
// )
// );
// }
//
// private static List<Method> getMethods() {
// return List.of(getMethod1());
// }
//
// private static Method getMethod1() {
// return new Method(
// true,
// ReturnType.BOOL,
// new Id("method"),
// List.of(),
// new Block(
// List.of(),
// List.of(
// new Return(
// new BoolLiteral(true)
// )
// )
// )
// );
// }
}

137
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_ClassWithMoreComplexMethodAndMain.java Normal file
View File

@ -0,0 +1,137 @@
//public class ClassWithMoreComplexMethodAndMain {
// ClassWithMoreComplexMethodAndMain instance;
//
// public boolean moreComplexMethod() {
// int i;
// i = 11;
// boolean returnValue;
// returnValue = false;
// while (i > 0) {
// i -= 1;
// returnValue = !returnValue;
// }
// return returnValue;
// }
//
// public static void main(String[] args) {
// instance = new ClassWithMoreComplexMethodAndMain()
// }
//}
import de.maishai.ast.*;
import de.maishai.ast.records.*;
import de.maishai.ast.records.Class;
import java.util.List;
public class TypedAbstractSyntax_ClassWithMoreComplexMethodAndMain {
// public static Class get() {
// Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
// TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
// List<Field> fields = List.of(
// new Field(
// new Id("instance"),
// TypeClassWithMoreComplexMethodAndMain
// )
// );
// List<Method> methods = getMethods();
// List<Constructor> constructors = List.of();
// return new Class(
// true,
// new Id("ClassWithMoreComplexMethodAndMain"),
// fields,
// methods,
// getMainMethod(),
// constructors
// );
// }
//
// private static List<Method> getMethods() {
// return List.of(getMethod1());
// }
//
// private static Method getMethod1() {
// Block block = new Block(
// List.of(
// new LocalVariable(
// new Id("i"),
// Type.INT
// ),
// new LocalVariable(
// new Id("returnValue"),
// Type.BOOL
// )
// ),
// List.of(
// new Assignment(
// new Id("i"),
// AssignSign.ASSIGN,
// new IntLiteral(11)
// ),
// new Assignment(
// new Id("returnValue"),
// AssignSign.ASSIGN,
// new BoolLiteral(false)
// ),
// new While(
// new Binary(
// new Id("i"),
// Operator.GT,
// new IntLiteral(0)
// ),
// new Block(
// List.of(),
// List.of(
// new Assignment(
// new Id("i"),
// AssignSign.SUB_ASSIGN,
// new IntLiteral(1)
// ),
// new Assignment(
// new Id("returnValue"),
// AssignSign.ASSIGN,
// new Unary(
// UnaryOperator.NOT,
// new Id("returnValue")
// )
// )
// )
// )
// ),
// new Return(
// new Id("returnValue")
// )
// )
// );
// return new Method(
// true,
// ReturnType.BOOL,
// new Id("moreComplexMethod"),
// List.of(),
// block
// );
// }
//
//
// private static MainMethod getMainMethod() {
// Type TypeClassWithMoreComplexMethodAndMain = Type.OBJECT;
// TypeClassWithMoreComplexMethodAndMain.setObjectType(new Id("ClassWithMoreComplexMethodAndMain"));
// List<Statement> statementList = List.of(
// new Assignment(
// new Id("instance"),
// AssignSign.ASSIGN,
// new New(
// TypeClassWithMoreComplexMethodAndMain,
// List.of()
// )
// )
// );
// Block block = new Block(
// List.of(),
// statementList
// );
// return new MainMethod(
// block
// );
// }
}

19
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_OnlyClass.java Normal file
View File

@ -0,0 +1,19 @@
//class OnlyClass {
//}
import de.maishai.typedast.typedclass.*;
import java.util.List;
public class TypedAbstractSyntax_OnlyClass {
public static TypedClass get() {
TypedClass typedClass = new TypedClass();
typedClass.setIsPublic(false);
typedClass.setTypedId(new TypedId("OnlyClass"));
typedClass.setTypedFields(List.of());
typedClass.setTypedMethods(List.of());
typedClass.setTypedMainMethod(null);
typedClass.setTypedConstructors(List.of());
return typedClass;
}
}

19
src/main/resources/TypedAbstractSyntax/TypedAbstractSyntax_PublicClass.java Normal file
View File

@ -0,0 +1,19 @@
//public class PublicClass {
//}
import de.maishai.typedast.typedclass.*;
import java.util.List;
public class TypedAbstractSyntax_PublicClass {
public static TypedClass get() {
TypedClass typedClass = new TypedClass();
typedClass.setIsPublic(true);
typedClass.setTypedId(new TypedId("PublicClass"));
typedClass.setTypedFields(List.of());
typedClass.setTypedMethods(List.of());
typedClass.setTypedMainMethod(null);
typedClass.setTypedConstructors(List.of());
return typedClass;
}
}