parser: Use Java Language Specification CFG

src/ws/codewash/CodeWash.java

@@ -6,6 +6,7 @@
 import ws.codewash.analyzer.reports.Report;
 import ws.codewash.parser.ParsedSourceTree;
 import ws.codewash.parser.Parser;
+import ws.codewash.parser.grammar.Grammar;
 import ws.codewash.reader.FolderReader;
 import ws.codewash.reader.SourceReadable;
 import ws.codewash.reader.ZipReader;
@@ -18,7 +19,7 @@
 import java.util.List;
 
 public class CodeWash {
-	private static final String TAG = "CODEWASH";
+	private static final String TAG = "CodeWash";
 
 	public static void main(String[] args) throws IOException {
 		JCommander commander = JCommander.newBuilder()
@@ -46,8 +47,9 @@ public static void main(String[] args) throws IOException {
 					sources = new FolderReader(Paths.get(Arguments.get().getSrcPath()));
 				}
 
-				ParsedSourceTree parsedSourceTree = new Parser().parse(sources.getSources());
-				List<Report> reports = new Analyzer(parsedSourceTree).analyse();
+				Grammar grammar = Grammar.parse(Paths.get("resources/language/java-11.cwls"));
+				ParsedSourceTree tree = new Parser(grammar).parse(sources.getSources());
+				List<Report> reports = new Analyzer(tree).analyse();
 
 			} else {
 				//Todo: Create http server

src/ws/codewash/analyzer/Analyzer.java

@@ -10,7 +10,7 @@
 import java.util.List;
 
 public class Analyzer {
-	private final static String TAG = "ANALYZER";
+	private final static String TAG = "Analyzer";
 	private List<CodeSmell> mCodeSmells = new ArrayList<>();
 
 	public Analyzer(ParsedSourceTree parsedSourceTree) {

src/ws/codewash/analyzer/smells/bloatedcode/LongClasses.java

@@ -4,7 +4,6 @@
 import ws.codewash.analyzer.reports.Report;
 import ws.codewash.analyzer.reports.Warning;
 import ws.codewash.analyzer.smells.CodeSmell;
-import ws.codewash.analyzer.smells.Smell;
 import ws.codewash.parser.ParsedSourceTree;
 import ws.codewash.util.Config;
 
@@ -35,9 +34,9 @@ public List<Report> run() {
 			totalLength += (int)value.getFields().parallelStream().count();
 
 			if (totalLength <= MAX_LENGTH && totalLength >= MID_LENGTH) {
-				reports.add(new ClassReport(Smell.LONG_CLASSES, value, Warning.CAUTION));
+				reports.add(new ClassReport(NAME, value, Warning.CAUTION));
 			} else if (totalLength > MAX_LENGTH){
-				reports.add(new ClassReport(Smell.LONG_CLASSES, value, Warning.ISSUE));
+				reports.add(new ClassReport(NAME, value, Warning.ISSUE));
 			}
 		});
 

src/ws/codewash/java/CWArray.java

@@ -4,6 +4,7 @@ public class CWArray extends CWReferenceType {
 	private CWType mType;
 
 	public CWArray(CWType type) {
+		super();
 		mType = type;
 	}
 

src/ws/codewash/java/CWBlock.java

@@ -0,0 +1,7 @@
+package ws.codewash.java;
+
+import java.util.List;
+
+public class CWBlock extends Scope {
+	private List<CWStatement> mStatements;
+}

src/ws/codewash/java/CWClass.java

@@ -7,16 +7,18 @@
 
 public class CWClass extends CWClassOrInterface {
 	private CWClass mSuperClass;
+	private String mPendingSuperClass;
 	private Set<CWClass> mSubClasses = new HashSet<>();
 
-	public CWClass(TypeResolver resolver, String _package, int modifiers, String name, String superClass, CWClassOrInterface outerClass, Collection<String> interfaces) {
-		super(resolver, _package, modifiers, name, outerClass, interfaces);
+	public CWClass(Scope enclosingScope, String _package, int modifiers, String name, String superClass, Collection<String> interfaces) {
+		super(enclosingScope, _package, modifiers, name, interfaces);
 
-		resolver.resolve(new PendingType<>(superClass, this::setSuperClass));
+		mPendingSuperClass = superClass;
+		enclosingScope.resolve(new PendingType<>(superClass, this::setSuperClass));
 	}
 
-	CWClass(TypeResolver resolver, Class _class) {
-		super(resolver, _class);
+	CWClass(Scope enclosingScope, Class _class) {
+		super(enclosingScope, _class);
 	}
 
 	@Override
@@ -40,4 +42,18 @@ private void addSubClass(CWClass subClass) {
 	public Set<CWClass> getSubClasses() {
 		return mSubClasses;
 	}
+
+	@Override
+	public String toString() {
+		StringBuilder builder = new StringBuilder();
+
+		builder.append(getModifiersForToString());
+		builder.append("class ");
+		builder.append(getSimpleName());
+		if (!mPendingSuperClass.equals(Object.class.getName())) {
+			builder.append("extends ").append(mPendingSuperClass);
+		}
+
+		return builder.toString();
+	}
 }

src/ws/codewash/java/CWClassOrInterface.java

@@ -1,12 +1,14 @@
 package ws.codewash.java;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import static ws.codewash.parser.ParsedSourceTree.dot;
 
-public abstract class CWClassOrInterface extends CWReferenceType implements Modifiable {
+public abstract class CWClassOrInterface extends CWReferenceType implements CWParameterizable, Modifiable {
 	private final Class mClass;
 	private final String mPackageName;
 	private Set<CWInterface> mInterfaces = new HashSet<>();
@@ -17,29 +19,36 @@ public abstract class CWClassOrInterface extends CWReferenceType implements Modi
 	private CWClassOrInterface mOuterClass;
 	private Set<CWClassOrInterface> mInnerClasses = new HashSet<>();
 
+	private List<CWTypeParameter> mTypeParameters = new ArrayList<>();
+
+	private Set<CWInitializer> mInitializers = new HashSet<>();
 	private Set<CWConstructor> mConstructors = new HashSet<>();
 	private Set<CWMethod> mMethods = new HashSet<>();
 	private Set<CWField> mFields = new HashSet<>();
 
-	CWClassOrInterface(TypeResolver resolver, String packageName, int modifiers, String name, CWClassOrInterface outerClass, Collection<String> interfaces) {
+	CWClassOrInterface(Scope enclosingScope, String packageName, int modifiers, String name, Collection<String> interfaces) {
+		super(enclosingScope);
+
 		mClass = null;
 		mPackageName = packageName;
 		mName = name;
 
 		mModifiers = modifiers;
 
 		// Outer class
-		if (outerClass != null) {
-			setOuterClass(outerClass);
+		if (enclosingScope instanceof CWClassOrInterface) {
+			setOuterClass((CWClassOrInterface) enclosingScope);
 		}
 
 		// Interfaces
 		for (String _interface : interfaces) {
-			resolver.resolve(new PendingType<>(_interface, this::addInterface));
+			enclosingScope.resolve(new PendingType<>(_interface, this::addInterface));
 		}
 	}
 
-	CWClassOrInterface(TypeResolver resolver, Class _class) {
+	CWClassOrInterface(Scope enclosingScope, Class _class) {
+		super(enclosingScope);
+
 		mClass = _class;
 		mPackageName = _class.getPackageName();
 		mName = _class.getSimpleName();
@@ -48,30 +57,47 @@ public abstract class CWClassOrInterface extends CWReferenceType implements Modi
 
 		// Outer class
 		if (_class.getEnclosingClass() != null) {
-			resolver.resolve(new PendingType<>(_class.getEnclosingClass().getName(), this::setOuterClass));
+			enclosingScope.resolve(new PendingType<>(_class.getEnclosingClass().getName(), this::setOuterClass));
 		}
 
 		// Interfaces
 		for (Class _interface : _class.getInterfaces()) {
-			resolver.resolve(new PendingType<>(_interface.getName(), this::addInterface));
+			enclosingScope.resolve(new PendingType<>(_interface.getName(), this::addInterface));
+		}
+
+		// TODO: _class.getTypeParameters()
+	}
+
+	public static Scope getExternalEnclosingScope(Class _class) {
+		if (_class.getDeclaringClass() != null) {
+			// TODO: TODO: TODO:
+			return forExternalClass(_class.getDeclaringClass());
 		}
+
+		return null;
 	}
 
-	public static CWClassOrInterface forExternalClass(TypeResolver resolver, Class _class) {
+	public static CWClassOrInterface forExternalClass(Class _class) {
+		Scope enclosingScope = getExternalEnclosingScope(_class);
 		CWClassOrInterface cwClassOrInterface;
 		if (_class.isEnum()) {
-			cwClassOrInterface = new CWEnum(resolver, _class);
+			cwClassOrInterface = new CWEnum(enclosingScope, _class);
 		} else if (_class.isInterface()) {
-			cwClassOrInterface = new CWInterface(resolver, _class);
+			cwClassOrInterface = new CWInterface(enclosingScope, _class);
 		} else {
-			cwClassOrInterface = new CWClass(resolver, _class);
+			cwClassOrInterface = new CWClass(enclosingScope, _class);
 		}
 
 		return cwClassOrInterface;
 	}
 
 	protected abstract int getValidModifiers();
 
+	public void addTypeParameter(CWTypeParameter typeParameter) {
+		mTypeParameters.add(typeParameter);
+		addTypeDeclaration(typeParameter.getVariableName(), typeParameter);
+	}
+
 	public void setOuterClass(CWClassOrInterface outerClass) {
 		mOuterClass = outerClass;
 		outerClass.addInnerClass(this);
@@ -140,6 +166,26 @@ public int getModifiers() {
 		return mModifiers;
 	}
 
+	public void addInitializer(CWInitializer initializer) {
+		mInitializers.add(initializer);
+	}
+
+	public void addConstructor(CWConstructor constructor) {
+		mConstructors.add(constructor);
+	}
+
+	public void addMethod(CWMethod method) {
+		mMethods.add(method);
+	}
+
+	public void addField(CWField field) {
+		mFields.add(field);
+	}
+
+	public Set<CWInitializer> getInitializers() {
+		return mInitializers;
+	}
+
 	public Set<CWConstructor> getConstructors() {
 		return mConstructors;
 	}

src/ws/codewash/java/CWConstructor.java

@@ -1,21 +1,52 @@
 package ws.codewash.java;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
-public class CWConstructor {
+public class CWConstructor extends Scope implements CWConstructorOrMethod, CWParameterizable, Modifiable {
 	private final CWClassOrInterface mParent;
-	private final List<CWVariable> mParameters;
 
-	public CWConstructor(CWClassOrInterface parent, List<CWVariable> parameters) {
+	private final int mModifiers;
+
+	private final List<CWTypeParameter> mTypeParameters = new ArrayList<>();
+	private final List<CWVariable> mParameters = new ArrayList<>();
+
+	public CWConstructor(CWClassOrInterface parent, int modifiers) {
 		mParent = parent;
-		mParameters = parameters;
+		mModifiers = modifiers;
+	}
+
+	public void addTypeParameter(CWTypeParameter typeParameter) {
+		mTypeParameters.add(typeParameter);
+		addTypeDeclaration(typeParameter.getVariableName(), typeParameter);
+	}
+
+	public void addParameter(CWVariable parameter) {
+		mParameters.add(parameter);
+		addLocalVariableDeclaration(parameter.getName(), parameter);
 	}
 
 	private CWClassOrInterface getParent() {
 		return mParent;
 	}
 
+	private List<CWTypeParameter> getTypeParameters() {
+		return mTypeParameters;
+	}
+
 	private List<CWVariable> getParameters() {
 		return mParameters;
 	}
+
+	@Override
+	public int getModifiers() {
+		return mModifiers;
+	}
+
+	@Override
+	public String toString() {
+		return getModifiersForToString() + mParent.getSimpleName() +
+				"(" + mParameters.stream().map(CWVariable::toString).collect(Collectors.joining(", ")) + ")";
+	}
 }

src/ws/codewash/java/CWConstructorOrMethod.java

@@ -0,0 +1,5 @@
+package ws.codewash.java;
+
+public interface CWConstructorOrMethod {
+	void addParameter(CWVariable parameter);
+}

src/ws/codewash/java/CWControlStatement.java

@@ -0,0 +1,4 @@
+package ws.codewash.java;
+
+public abstract class CWControlStatement extends CWStatement {
+}

src/ws/codewash/java/CWEnum.java

@@ -1,15 +1,28 @@
 package ws.codewash.java;
 
 import java.lang.reflect.Modifier;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 
 public class CWEnum extends CWClassOrInterface {
-	public CWEnum(TypeResolver resolver, String _package, int modifiers, String name, CWClassOrInterface outerClass, Collection<String> interfaces) {
-		super(resolver, _package, modifiers, name, outerClass, interfaces);
+	private List<String> mConstants = new ArrayList<>();
+
+	public CWEnum(Scope enclosingScope, String _package, int modifiers, String name, Collection<String> interfaces) {
+		super(enclosingScope, _package, modifiers, name, interfaces);
+	}
+
+	CWEnum(Scope enclosingScope, Class _class) {
+		super(enclosingScope, _class);
+	}
+
+	public List<String> getConstants() {
+		return mConstants;
 	}
 
-	CWEnum(TypeResolver resolver, Class _class) {
-		super(resolver, _class);
+	public void addConstant(String constant) {
+		mConstants.add(constant);
 	}
 
 	@Override

src/ws/codewash/java/CWExpression.java

@@ -0,0 +1,4 @@
+package ws.codewash.java;
+
+public class CWExpression extends CWStatement {
+}

src/ws/codewash/java/CWField.java

@@ -1,19 +1,16 @@
 package ws.codewash.java;
 
-public class CWField extends CWMember {
-	private CWType mType;
+public class CWField extends CWVariable implements CWMember, Modifiable {
+	private CWClassOrInterface mParent;
 
-	public CWField(TypeResolver resolver, CWClass parent, int modifiers, String name, String type) {
-		super(resolver, parent, modifiers, name);
+	public CWField(CWClassOrInterface parent, int modifiers, String type, String name) {
+		super(parent, modifiers, type, name);
 
-		resolver.resolve(new PendingType<>(type, this::setType));
+		mParent = parent;
 	}
 
-	public CWType getType() {
-		return mType;
-	}
-
-	private void setType(CWType type) {
-		mType = type;
+	@Override
+	public CWClassOrInterface getParent() {
+		return mParent;
 	}
 }