Implement Ignore on supertype

Author: cuzfrog

annotation/src/main/java/org/sharedtype/annotation/SharedType.java

@@ -46,7 +46,7 @@
     /**
      * <p>
      * The name of the emitted type. If not specified, the simple name of the annotated type will be used.
-     * This may be used to help avoid conflicting names in target output.
+     * This may be used to help avoid conflicting names in target code.
      * </p>
      * <br>
      * <p>
@@ -59,36 +59,35 @@
     String name() default "";
 
     /**
-     * Includes fields, record components, accessors, or constants in a type.
      * <p>
-     * To exclude a particular component, use {@link Ignore}.
+     * Configure whether to include fields, record components, accessors, or constants in a type.
+     * All included by default.
      * </p>
      * <p>
-     * Fields and accessors duplicates resolution:
-     *     <ul>
-     *         <li>In classes, fields and accessors effectively with the same name will be merged.</li>
-     *         <li>Same for record.</li>
-     *     </ul>
+     * To exclude a particular component, use {@link Ignore}.
+     * Fields and accessors effectively with the same name will be merged.
      * </p>
      *
      * @see ComponentType#FIELDS
      * @see ComponentType#ACCESSORS
      * @see ComponentType#CONSTANTS
      */
-    ComponentType[] includes() default {ComponentType.FIELDS, ComponentType.ACCESSORS};
+    ComponentType[] includes() default {ComponentType.FIELDS, ComponentType.ACCESSORS, ComponentType.CONSTANTS};
 
     /**
-     * Mark a method as an accessor regardless of its name. This annotation will be ignored if {@link #includes()} does not include {@link ComponentType#ACCESSORS}.
+     * Mark a method as an accessor regardless of its name.
+     * Getter prefixes are configured in global properties.
+     * This annotation will be ignored if {@link #includes()} does not include {@link ComponentType#ACCESSORS}.
      */
     @Target({ElementType.METHOD})
     @Retention(RetentionPolicy.SOURCE)
     @interface Accessor {
     }
 
     /**
-     * Exclude fields, record components, accessors in a type. Or ignore a dependent type, e.g. a supertype.
+     * Exclude fields, record components, accessors in a type, or a dependency type, e.g. a supertype.
      * <p>
-     * <b>When placed on type:</b> a subtype of this type will not include inherited members from this type.
+     * <b>When placed on a type:</b> a subtype of this type will not extend this type in target code.
      * But if this type is referenced directly as type of a field or return type of an accessor, an error will be reported,
      * unless the field or accessor is also ignored.
      * </p>

internal/src/main/java/org/sharedtype/domain/TypeVariableInfo.java

@@ -2,20 +2,22 @@
 
 import lombok.Builder;
 import lombok.EqualsAndHashCode;
-import lombok.Getter;
 
 /**
  * Represents a generic type variable.
  *
  * @author Cause Chung
  */
-@Getter
 @EqualsAndHashCode
 @Builder
 public final class TypeVariableInfo implements TypeInfo {
     private final String name;
     // TODO: support generic bounds
 
+    public String name() {
+        return name;
+    }
+
     @Override
     public boolean resolved() {
         return true;

it/java17/src/main/java/org/sharedtype/it/java17/JavaRecord.java

@@ -63,4 +63,9 @@ String getDuplicateAccessor() {
     String shouldNotBeIncluded() {
         return null;
     }
+
+    @Override
+    public T getValue() {
+        return null;
+    }
 }

it/java17/src/test/java/org/sharedtype/it/JavaRecordIntegrationTest.java

@@ -5,6 +5,7 @@
 import org.sharedtype.domain.ArrayTypeInfo;
 import org.sharedtype.domain.ClassDef;
 import org.sharedtype.domain.ConcreteTypeInfo;
+import org.sharedtype.domain.TypeVariableInfo;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.sharedtype.it.TypeDefDeserializer.deserializeTypeDef;
@@ -18,8 +19,8 @@ void typeVariables() {
         var typeParameters = classDef.typeVariables();
         assertThat(typeParameters).hasSize(2);
 
-        assertThat(typeParameters.get(0).getName()).isEqualTo("T");
-        assertThat(typeParameters.get(1).getName()).isEqualTo("K");
+        assertThat(typeParameters.get(0).name()).isEqualTo("T");
+        assertThat(typeParameters.get(1).name()).isEqualTo("K");
     }
 
     @Test
@@ -289,8 +290,16 @@ void duplicateAccessorField() {
         assertThat(typeInfo.qualifiedName()).isEqualTo("java.lang.String");
     }
 
+    @Test
+    void implementedMethodGetValueFromInterface() {
+        var method = classDef.components().get(31);
+        assertThat(method.name()).isEqualTo("value");
+        var typeInfo = (TypeVariableInfo)method.type();
+        assertThat(typeInfo.name()).isEqualTo("T");
+    }
+
     @Test
     void fieldsSize() {
-        assertThat(classDef.components().size()).isEqualTo(31);
+        assertThat(classDef.components().size()).isEqualTo(32);
     }
 }

it/java17/src/test/java/org/sharedtype/it/TypeDefIntegrationTest.java

@@ -21,13 +21,13 @@ void container() {
             softly.assertThat(container.components()).hasSize(1);
             val component1 = container.components().get(0);
             val field1Type = (TypeVariableInfo) component1.type();
-            softly.assertThat(field1Type.getName()).isEqualTo("T");
+            softly.assertThat(field1Type.name()).isEqualTo("T");
             softly.assertThat(component1.name()).isEqualTo("t");
 
             softly.assertThat(container.resolved()).isTrue();
             softly.assertThat(container.typeVariables()).hasSize(1);
             val typeVariable1 = container.typeVariables().get(0);
-            softly.assertThat(typeVariable1.getName()).isEqualTo("T");
+            softly.assertThat(typeVariable1.name()).isEqualTo("T");
         });
     }
 
@@ -115,13 +115,7 @@ void interfaceA() {
     @Test
     void superClassA() {
         ClassDef superClassA = (ClassDef) deserializeTypeDef("org.sharedtype.it.java8.SuperClassA.ser");
-        SoftAssertions.assertSoftly(softly -> {
-            softly.assertThat(superClassA.simpleName()).isEqualTo("SuperClassA");
-            softly.assertThat(superClassA.components()).hasSize(1);
-            val component1 = superClassA.components().get(0);
-            softly.assertThat(component1.name()).isEqualTo("a");
-            val component1type = (ConcreteTypeInfo) component1.type();
-            softly.assertThat(component1type.qualifiedName()).isEqualTo("int");
-        });
+        assertThat(superClassA.simpleName()).isEqualTo("SuperClassA");
+        assertThat(superClassA.qualifiedName()).isEqualTo("org.sharedtype.it.java8.SuperClassA");
     }
 }

it/java8/src/main/java/org/sharedtype/it/java8/IgnoredInterfaceB.java

@@ -0,0 +1,12 @@
+package org.sharedtype.it.java8;
+
+import org.sharedtype.annotation.SharedType;
+
+@SharedType.Ignore
+interface IgnoredInterfaceB {
+    default boolean getBooleanValue() {
+        return false;
+    }
+
+    // TODO: add method, and check implemented method in subtype is not ignored
+}

it/java8/src/main/java/org/sharedtype/it/java8/IgnoredSuperClassB.java

@@ -0,0 +1,8 @@
+package org.sharedtype.it.java8;
+
+import org.sharedtype.annotation.SharedType;
+
+@SharedType.Ignore
+abstract class IgnoredSuperClassB {
+    int field;
+}

it/java8/src/main/java/org/sharedtype/it/java8/InterfaceA.java

@@ -1,4 +1,5 @@
 package org.sharedtype.it.java8;
 
 public interface InterfaceA<T> {
+    T getValue();
 }

it/java8/src/main/java/org/sharedtype/it/java8/JavaClass.java

@@ -3,7 +3,7 @@
 import org.sharedtype.annotation.SharedType;
 
 @SharedType
-class JavaClass {
+class JavaClass extends SuperClassA {
     private String string;
     private EnumSize size;
 

it/java8/src/main/java/org/sharedtype/it/java8/SuperClassA.java

@@ -1,5 +1,10 @@
 package org.sharedtype.it.java8;
 
-public abstract class SuperClassA {
+public abstract class SuperClassA extends IgnoredSuperClassB implements InterfaceA<Integer>, IgnoredInterfaceB {
     private int a;
+
+    @Override
+    public Integer getValue() {
+        return a;
+    }
 }