Show warnings for items not in IO

.gitignore

@@ -138,6 +138,7 @@ $RECYCLE.BIN/
 ### Gradle ###
 .gradle
 /build/
+/checker/build/
 
 # Ignore Gradle GUI config
 gradle-app.setting

build.gradle

@@ -68,6 +68,8 @@ dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
     testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
+
+    annotationProcessor project(":checker")
 }
 
 test {
@@ -96,6 +98,11 @@ wpi.java.configureTestTasks(test)
 // Configure string concat to always inline compile
 tasks.withType(JavaCompile) {
     options.compilerArgs.add '-XDstringConcat=inline'
+    // only run in GH actions
+    if (System.getenv("GITHUB_ACTOR") != null && !System.getenv("GITHUB_ACTOR").equals("")) {
+        options.compilerArgs << "-Xplugin:rchk"
+        outputs.upToDateWhen { false } // Force recompile, even if source file hasn't changed
+    }
 }
 
 javadoc {

checker/build.gradle

@@ -0,0 +1,27 @@
+
+plugins {
+    id 'java-library'
+}
+tasks.withType(JavaCompile) {
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'
+    options.compilerArgs << '--add-exports' << 'jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED'
+}
+
+sourceCompatibility = JavaVersion.VERSION_11
+targetCompatibility = JavaVersion.VERSION_11
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+
+}

checker/src/main/java/org/frc5572/robotools/Checks.java

@@ -0,0 +1,18 @@
+package org.frc5572.robotools;
+
+import org.frc5572.robotools.checks.*;
+
+public class Checks {
+
+    private static final Check[] CHECKS = new Check[] {
+        new ExampleCheck(),
+        new IOCheck(),
+    };
+
+    public static void process(CompilationData data) {
+        for(Check c : CHECKS) {
+            c.check(data);
+        }
+    }
+
+}

checker/src/main/java/org/frc5572/robotools/CompilationData.java

@@ -0,0 +1,120 @@
+package org.frc5572.robotools;
+
+import javax.annotation.processing.Messager;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.util.Types;
+import javax.tools.Diagnostic;
+
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.LineMap;
+import com.sun.source.tree.Tree;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.SourcePositions;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.Trees;
+
+public class CompilationData {
+
+    public Types types;
+    private Trees trees;
+    private SourcePositions positions;
+    private CompilationUnitTree compilationUnitTree;
+    public TypeElement element;
+    private Messager messager;
+
+    public CompilationData(Types types, Trees trees, SourcePositions positions, CompilationUnitTree compilationUnitTree,
+            TypeElement element, Messager messager) {
+        this.types = types;
+        this.trees = trees;
+        this.positions = positions;
+        this.compilationUnitTree = compilationUnitTree;
+        this.element = element;
+        this.messager = messager;
+    }
+
+    public CompilationData(JavacTask task, TaskEvent event) {
+        this(task.getTypes(), Trees.instance(task), Trees.instance(task).getSourcePositions(), event.getCompilationUnit(), event.getTypeElement(), null);
+    }
+
+    public CompilationData(ProcessingEnvironment processingEnv, TypeElement element) {
+        this(processingEnv.getTypeUtils(), null, null, null, element, processingEnv.getMessager());
+    }
+
+    public void error(Element element, Object object) {
+        echo(element, object.toString(), Diagnostic.Kind.ERROR, "error", "Error");
+    }
+
+    public void warn(Element element, Object object) {
+        echo(element, object.toString(), Diagnostic.Kind.MANDATORY_WARNING, "warning", "Warning");
+    }
+
+    public void note(Element element, Object object) {
+        echo(element, object.toString(), Diagnostic.Kind.NOTE, "notice", "Note");
+    }
+
+    private void echo(Element element, String errString, Diagnostic.Kind kind, String ghString, String humanString) {
+        if (compilationUnitTree == null) {
+            messager.printMessage(kind, errString, element);
+        } else {
+            Tree tree = trees.getTree(element);
+            LineMap linemap = compilationUnitTree.getLineMap();
+            long pos = positions.getStartPosition(compilationUnitTree, tree);
+            long row = linemap.getLineNumber(pos);
+            String name = compilationUnitTree.getSourceFile().toUri().toString().split("/src/")[1];
+            System.out.println("::" + ghString + " file=src/" + name + ",line=" + row + "::" + errString);
+        }
+    }
+
+    private boolean _implements(String qualifiedName, TypeElement elem) {
+        if(elem.getQualifiedName().toString().equals(qualifiedName)) {
+            return true;
+        }
+        Element superClass = types.asElement(elem.getSuperclass());
+        if(superClass instanceof TypeElement) {
+            if(_implements(qualifiedName, (TypeElement) superClass)) {
+                return true;
+            }
+        }
+        for(var iface : elem.getInterfaces()) {
+            Element interface_ = types.asElement(iface);
+            if(interface_ instanceof TypeElement) {
+                if(_implements(qualifiedName, (TypeElement) interface_)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean _extends(String qualifiedName, TypeElement elem) {
+        if(elem.getQualifiedName().toString().equals(qualifiedName)) {
+            return true;
+        }
+        Element superClass = types.asElement(elem.getSuperclass());
+        if(superClass instanceof TypeElement) {
+            if(_extends(qualifiedName, (TypeElement) superClass)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean implementsInterface(String qualifiedName) {
+        return _implements(qualifiedName, this.element);
+    }
+
+    public boolean implementsInterface(TypeElement e, String qualifiedName) {
+        return _implements(qualifiedName, e);
+    }
+
+    public boolean extendsClass(String qualifiedName) {
+        return _extends(qualifiedName, this.element);
+    }
+
+    public boolean extendsClass(TypeElement e, String qualifiedName) {
+        return _extends(qualifiedName, e);
+    }
+
+}

checker/src/main/java/org/frc5572/robotools/GetIdentifier.java

@@ -0,0 +1,13 @@
+package org.frc5572.robotools;
+
+import com.sun.source.util.TreeScanner;
+import com.sun.source.tree.IdentifierTree;
+
+public class GetIdentifier extends TreeScanner<String, Void> {
+
+    @Override
+    public String visitIdentifier(IdentifierTree node, Void p) {
+        return node.getName().toString();
+    }
+
+}

checker/src/main/java/org/frc5572/robotools/RobotPlugin.java

@@ -0,0 +1,35 @@
+package org.frc5572.robotools;
+
+import javax.lang.model.util.Types;
+
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.Plugin;
+import com.sun.source.util.SourcePositions;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.source.util.Trees;
+
+public class RobotPlugin implements Plugin {
+
+    @Override
+    public String getName() {
+        return "rchk";
+    }
+
+    @Override
+    public void init(JavacTask task, String... arg1) {
+        Types types = task.getTypes();
+        Trees trees = Trees.instance(task);
+        SourcePositions positions = trees.getSourcePositions();
+        task.addTaskListener(new TaskListener() {
+            @Override
+            public void finished(TaskEvent e) {
+                if (e.getKind() == TaskEvent.Kind.ANALYZE) {
+                    CompilationData data = new CompilationData(types, trees, positions, e.getCompilationUnit(), e.getTypeElement(), null);
+                    Checks.process(data);
+                }
+            }
+        });
+    }
+
+}

checker/src/main/java/org/frc5572/robotools/RobotProcessor.java

@@ -0,0 +1,68 @@
+package org.frc5572.robotools;
+
+import java.util.Set;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedOptions;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ModuleElement;
+import javax.lang.model.element.PackageElement;
+import javax.lang.model.element.TypeElement;
+
+@SupportedAnnotationTypes("*")
+@SupportedSourceVersion(SourceVersion.RELEASE_11)
+@SupportedOptions("frc_check.skip")
+public class RobotProcessor extends AbstractProcessor {
+
+    private void processTypeElement(TypeElement typeElement) {
+        for (Element e3 : typeElement.getEnclosedElements()) {
+            if (e3 instanceof TypeElement) {
+                processTypeElement((TypeElement) e3);
+            }
+        }
+        CompilationData data = new CompilationData(processingEnv, typeElement);
+        Checks.process(data);
+    }
+
+    private boolean hasProcessed;
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+        super.init(processingEnv);
+        System.out.println(processingEnv.getOptions().get("frc_check.skip"));
+        hasProcessed = false;
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> arg0, RoundEnvironment roundEnv) {
+        if(hasProcessed) {
+            return false;
+        }
+        hasProcessed = true;
+        for (ModuleElement m : processingEnv.getElementUtils().getAllModuleElements()) {
+            if (!m.isUnnamed()) {
+                continue;
+            }
+            for (Element e : m.getEnclosedElements()) {
+                if (e instanceof PackageElement) {
+                    PackageElement pe = (PackageElement) e;
+                    if (pe.getQualifiedName().toString().startsWith("frc.")) {
+                        for (Element e2 : pe.getEnclosedElements()) {
+                            if (e2 instanceof TypeElement) {
+                                TypeElement te = (TypeElement) e2;
+                                processTypeElement(te);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}

checker/src/main/java/org/frc5572/robotools/checks/Check.java

@@ -0,0 +1,10 @@
+package org.frc5572.robotools.checks;
+
+import org.frc5572.robotools.CompilationData;
+
+@FunctionalInterface
+public interface Check {
+
+    public boolean check(CompilationData data);
+
+}

checker/src/main/java/org/frc5572/robotools/checks/ExampleCheck.java

@@ -0,0 +1,13 @@
+package org.frc5572.robotools.checks;
+
+import org.frc5572.robotools.CompilationData;
+
+public class ExampleCheck implements Check {
+
+    @Override
+    public boolean check(CompilationData data) {
+
+        return false;
+    }
+
+}