[BAEL-9555] - Created a core-java-modules folder

core-java-modules/core-java-sun/src/main/java/com/baeldung/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

core-java-modules/core-java-sun/src/main/java/com/baeldung/README.md

@@ -0,0 +1 @@
+### Relevant Articles:

core-java-modules/core-java-sun/src/main/java/com/baeldung/javac/Positive.java

@@ -0,0 +1,9 @@
+package com.baeldung.javac;
+
+import java.lang.annotation.*;
+
+@Documented
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.PARAMETER})
+public @interface Positive {
+}

core-java-modules/core-java-sun/src/main/java/com/baeldung/javac/SampleJavacPlugin.java

@@ -0,0 +1,123 @@
+package com.baeldung.javac;
+
+import com.sun.source.tree.MethodTree;
+import com.sun.source.tree.VariableTree;
+import com.sun.source.util.*;
+import com.sun.tools.javac.api.BasicJavacTask;
+import com.sun.tools.javac.code.TypeTag;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Names;
+
+import javax.tools.JavaCompiler;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.sun.tools.javac.util.List.nil;
+
+/**
+ * A {@link JavaCompiler javac} plugin which inserts {@code >= 0} checks into resulting {@code *.class} files
+ * for numeric method parameters marked by {@link Positive}
+ */
+public class SampleJavacPlugin implements Plugin {
+
+    public static final String NAME = "MyPlugin";
+
+    private static Set<String> TARGET_TYPES = new HashSet<>(Arrays.asList(
+        // Use only primitive types for simplicity
+        byte.class.getName(), short.class.getName(), char.class.getName(), 
+        int.class.getName(), long.class.getName(), float.class.getName(), double.class.getName()));
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public void init(JavacTask task, String... args) {
+        Context context = ((BasicJavacTask) task).getContext();
+        task.addTaskListener(new TaskListener() {
+            @Override
+            public void started(TaskEvent e) {
+            }
+
+            @Override
+            public void finished(TaskEvent e) {
+                if (e.getKind() != TaskEvent.Kind.PARSE) {
+                    return;
+                }
+                e.getCompilationUnit()
+                    .accept(new TreeScanner<Void, Void>() {
+                        @Override
+                        public Void visitMethod(MethodTree method, Void v) {
+                            List<VariableTree> parametersToInstrument = method.getParameters()
+                                .stream()
+                                .filter(SampleJavacPlugin.this::shouldInstrument)
+                                .collect(Collectors.toList());
+                            if (!parametersToInstrument.isEmpty()) {
+                                // There is a possible case that more than one argument is marked by @Positive,
+                                // as the checks are added to the method's body beginning, we process parameters RTL
+                                // to ensure correct order.
+                                Collections.reverse(parametersToInstrument);
+                                parametersToInstrument.forEach(p -> addCheck(method, p, context));
+                            }
+                            // There is a possible case that there is a nested class declared in a method's body,
+                            // hence, we want to proceed with method body AST as well.
+                            return super.visitMethod(method, v);
+                        }
+                    }, null);
+            }
+        });
+    }
+
+    private boolean shouldInstrument(VariableTree parameter) {
+        return TARGET_TYPES.contains(parameter.getType().toString())
+          && parameter.getModifiers().getAnnotations()
+            .stream()
+            .anyMatch(a -> Positive.class.getSimpleName().equals(a.getAnnotationType().toString()));
+    }
+
+    private void addCheck(MethodTree method, VariableTree parameter, Context context) {
+        JCTree.JCIf check = createCheck(parameter, context);
+        JCTree.JCBlock body = (JCTree.JCBlock) method.getBody();
+        body.stats = body.stats.prepend(check);
+    }
+
+    private static JCTree.JCIf createCheck(VariableTree parameter, Context context) {
+        TreeMaker factory = TreeMaker.instance(context);
+        Names symbolsTable = Names.instance(context);
+        
+        return factory.at(((JCTree) parameter).pos)
+          .If(factory.Parens(createIfCondition(factory, symbolsTable, parameter)),
+            createIfBlock(factory, symbolsTable, parameter),
+            null);
+    }
+
+    private static JCTree.JCBinary createIfCondition(TreeMaker factory, Names symbolsTable, VariableTree parameter) {
+        Name parameterId = symbolsTable.fromString(parameter.getName().toString());
+        return factory.Binary(JCTree.Tag.LE, 
+          factory.Ident(parameterId), 
+          factory.Literal(TypeTag.INT, 0));
+    }
+
+    private static JCTree.JCBlock createIfBlock(TreeMaker factory, Names symbolsTable, VariableTree parameter) {
+        String parameterName = parameter.getName().toString();
+        Name parameterId = symbolsTable.fromString(parameterName);
+        
+        String errorMessagePrefix = String.format("Argument '%s' of type %s is marked by @%s but got '", 
+          parameterName, parameter.getType(), Positive.class.getSimpleName());
+        String errorMessageSuffix = "' for it";
+        
+        return factory.Block(0, com.sun.tools.javac.util.List.of(
+          factory.Throw(
+            factory.NewClass(null, nil(), 
+              factory.Ident(symbolsTable.fromString(IllegalArgumentException.class.getSimpleName())),
+                com.sun.tools.javac.util.List.of(factory.Binary(JCTree.Tag.PLUS, 
+                  factory.Binary(JCTree.Tag.PLUS, factory.Literal(TypeTag.CLASS, errorMessagePrefix), 
+                    factory.Ident(parameterId)), 
+                    factory.Literal(TypeTag.CLASS, errorMessageSuffix))), null))));
+    }
+
+}

core-java-modules/core-java-sun/src/main/resources/META-INF/services/com.sun.source.util.Plugin

@@ -0,0 +1 @@
+com.baeldung.javac.SampleJavacPlugin

core-java-modules/core-java-sun/src/main/resources/log4j.properties

@@ -0,0 +1,6 @@
+log4j.rootLogger=DEBUG, A1
+
+log4j.appender.A1=org.apache.log4j.ConsoleAppender
+
+log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

core-java-modules/core-java-sun/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>