fix: add various fixes to parser and generator (#186)

* refactor(java/parser-jvm-core): use pool to avoid endless wrapper creation

* refactor(java/parser-jvm-plugin-nonnull): add default config

* Revert "refactor(java/parser-jvm-core): use pool to avoid endless wrapper creation"

This reverts commit 871fece.

* refactor(java/parser-jvm-core): use lazy memoized request for collecting element's members

* fix(java): use correct detection for Optional & other system classes

* fix(ts): fix various TS issues

- Logging from different plugins
- Use plugin itself as a context

* fix(ts/generator-typescript-plugin-model): use separate export default statement

* fix(java/parser-jvm-plugin-backbone): ignore synthetic classes

* style(java/parser-jvm-core): format

* chore(ts): fix dependecies issue

* style(java/parser-jvm-plugin-nonnull): format

* test(java/parser-jvm-plugin-backbone): update fixture

* test(ts/generator-typescript-plugin-client): fix logger import

* refactor(ts/generator-typescript-plugin-model): rename context -> owner

* test(java/parser-jvm-plugin-nonnull): update fixture

* fix(ts/generator-typescript-plugin-backbone): rename context -> owner

* test(ts/generator-typescript-plugin-barrel): fix logger import

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/ArrayRelativeTypeSignature.java

@@ -11,6 +11,8 @@
 public final class ArrayRelativeTypeSignature
         extends AbstractRelative<ArrayTypeSignature, Relative<?>>
         implements RelativeTypeSignature {
+    private RelativeTypeSignature nestedType;
+
     ArrayRelativeTypeSignature(ArrayTypeSignature origin, Relative<?> parent) {
         super(origin, parent);
     }
@@ -22,7 +24,11 @@ public static Stream<ClassInfo> resolve(
     }
 
     public RelativeTypeSignature getNestedType() {
-        return RelativeTypeSignature.of(origin.getNestedType(), this);
+        if (nestedType == null) {
+            nestedType = RelativeTypeSignature.of(origin.getNestedType(), this);
+        }
+
+        return nestedType;
     }
 
     @Override

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/BaseRelativeTypeSignature.java

@@ -33,8 +33,6 @@ public boolean isBoolean() {
 
     @Override
     public boolean isByte() {
-        var type = origin.getType();
-
         return origin.getType() == Byte.TYPE;
     }
 

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/ClassRefRelativeTypeSignature.java

@@ -17,21 +17,13 @@ public final class ClassRefRelativeTypeSignature
         extends AbstractRelative<ClassRefTypeSignature, Relative<?>>
         implements RelativeTypeSignature {
     private final ReflectedClass reflectedClass;
-    private final List<List<RelativeTypeArgument>> suffixTypeArguments;
-    private final List<RelativeTypeArgument> typeArguments;
+    private List<List<RelativeTypeArgument>> suffixTypeArguments;
+    private List<RelativeTypeArgument> typeArguments;
 
     ClassRefRelativeTypeSignature(ClassRefTypeSignature origin,
             Relative<?> parent) {
         super(origin, parent);
         reflectedClass = new ReflectedClass(origin);
-        typeArguments = origin.getTypeArguments().stream()
-                .map(arg -> new RelativeTypeArgument(arg, this))
-                .collect(Collectors.toList());
-        suffixTypeArguments = origin.getSuffixTypeArguments().stream()
-                .map(list -> list.stream()
-                        .map(arg -> new RelativeTypeArgument(arg, this))
-                        .collect(Collectors.toList()))
-                .collect(Collectors.toList());
     }
 
     public static Stream<ClassInfo> resolve(
@@ -50,10 +42,24 @@ public static Stream<ClassInfo> resolve(
     }
 
     public List<List<RelativeTypeArgument>> getSuffixTypeArguments() {
+        if (suffixTypeArguments == null) {
+            suffixTypeArguments = origin.getSuffixTypeArguments().stream()
+                    .map(list -> list.stream()
+                            .map(arg -> new RelativeTypeArgument(arg, this))
+                            .collect(Collectors.toList()))
+                    .collect(Collectors.toList());
+        }
+
         return suffixTypeArguments;
     }
 
     public List<RelativeTypeArgument> getTypeArguments() {
+        if (typeArguments == null) {
+            typeArguments = origin.getTypeArguments().stream()
+                    .map(arg -> new RelativeTypeArgument(arg, this))
+                    .collect(Collectors.toList());
+        }
+
         return typeArguments;
     }
 
@@ -139,6 +145,6 @@ public boolean isString() {
 
     @Override
     public boolean isSystem() {
-        return origin.getClassInfo() == null;
+        return origin.getClassInfo() == null || reflectedClass.isJDKClass();
     }
 }

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/ReflectedClass.java

@@ -91,6 +91,10 @@ public boolean isIterable() {
         return Iterable.class.isAssignableFrom(origin);
     }
 
+    public boolean isJDKClass() {
+        return ParserUtils.isJDKClass(origin.getName());
+    }
+
     public boolean isLong() {
         return Long.class.isAssignableFrom(origin);
     }

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/RelativeClassInfo.java

@@ -2,11 +2,11 @@
 
 import static com.vaadin.fusion.parser.core.ParserUtils.isJDKClass;
 
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -19,13 +19,13 @@
 
 public final class RelativeClassInfo
         extends AbstractRelative<ClassInfo, RelativeClassInfo> {
-    private final List<RelativeAnnotationInfo> annotations;
     private final InheritanceChain chain;
-    private final List<RelativeFieldInfo> fields;
-    private final List<RelativeClassInfo> innerClasses;
-    private final List<RelativeMethodInfo> methods;
     private final RelativeClassInfo superClass;
-    private final List<RelativeClassInfo> superClasses;
+    private List<RelativeAnnotationInfo> annotations;
+    private List<RelativeFieldInfo> fields;
+    private List<RelativeClassInfo> innerClasses;
+    private List<RelativeMethodInfo> methods;
+    private List<RelativeClassInfo> superClasses;
 
     public RelativeClassInfo(@Nonnull ClassInfo origin) {
         this(origin, null);
@@ -35,17 +35,6 @@ public RelativeClassInfo(@Nonnull ClassInfo origin,
             RelativeClassInfo parent) {
         super(origin, parent);
 
-        annotations = getMembers(ClassInfo::getAnnotationInfo,
-                RelativeAnnotationInfo::new);
-        fields = getMembers(ClassInfo::getDeclaredFieldInfo,
-                RelativeFieldInfo::new);
-        innerClasses = getMembers(ClassInfo::getInnerClasses,
-                RelativeClassInfo::new);
-        methods = getMembers(ClassInfo::getDeclaredMethodInfo,
-                RelativeMethodInfo::new);
-        superClasses = getMembers(ClassInfo::getSuperclasses,
-                (member) -> !isJDKClass(member), RelativeClassInfo::new);
-
         var originSuperClass = origin.getSuperclass();
         superClass = originSuperClass != null
                 ? new RelativeClassInfo(originSuperClass)
@@ -55,6 +44,19 @@ public RelativeClassInfo(@Nonnull ClassInfo origin,
         chain = new InheritanceChain();
     }
 
+    public List<RelativeAnnotationInfo> getAnnotations() {
+        if (annotations == null) {
+            annotations = getMembers(ClassInfo::getAnnotationInfo,
+                    RelativeAnnotationInfo::new);
+        }
+
+        return annotations;
+    }
+
+    public Stream<RelativeAnnotationInfo> getAnnotationsStream() {
+        return getAnnotations().stream();
+    }
+
     @Override
     public Stream<RelativeClassInfo> getDependenciesStream() {
         return Stream
@@ -73,11 +75,16 @@ public Stream<RelativeClassInfo> getFieldDependenciesStream() {
     }
 
     public List<RelativeFieldInfo> getFields() {
+        if (fields == null) {
+            fields = getMembers(ClassInfo::getDeclaredFieldInfo,
+                    RelativeFieldInfo::new);
+        }
+
         return fields;
     }
 
     public Stream<RelativeFieldInfo> getFieldsStream() {
-        return fields.stream();
+        return getFields().stream();
     }
 
     public InheritanceChain getInheritanceChain() {
@@ -94,11 +101,16 @@ public Stream<RelativeClassInfo> getInnerClassDependenciesStream() {
     }
 
     public List<RelativeClassInfo> getInnerClasses() {
+        if (innerClasses == null) {
+            innerClasses = getMembers(ClassInfo::getInnerClasses,
+                    RelativeClassInfo::new);
+        }
+
         return innerClasses;
     }
 
     public Stream<RelativeClassInfo> getInnerClassesStream() {
-        return innerClasses.stream();
+        return getInnerClasses().stream();
     }
 
     public <RelativeMember extends Relative<?>> List<RelativeClassInfo> getMemberDependencies(
@@ -174,11 +186,16 @@ public Stream<RelativeClassInfo> getMethodDependenciesStream() {
     }
 
     public List<RelativeMethodInfo> getMethods() {
+        if (methods == null) {
+            methods = getMembers(ClassInfo::getDeclaredMethodInfo,
+                    RelativeMethodInfo::new);
+        }
+
         return methods;
     }
 
     public Stream<RelativeMethodInfo> getMethodsStream() {
-        return methods.stream();
+        return getMethods().stream();
     }
 
     @Override
@@ -191,39 +208,49 @@ public Optional<RelativeClassInfo> getSuperClass() {
     }
 
     public List<RelativeClassInfo> getSuperClasses() {
+        if (superClasses == null) {
+            superClasses = getMembers(ClassInfo::getSuperclasses,
+                    (member) -> !isJDKClass(member), RelativeClassInfo::new);
+        }
+
         return superClasses;
     }
 
     public Stream<RelativeClassInfo> getSuperClassesStream() {
-        return superClasses.stream();
+        return getSuperClasses().stream();
     }
 
     private <T> boolean defaultFilter(T member) {
         return true;
     }
 
     public class InheritanceChain {
-        private final Set<RelativeClassInfo> chain = new HashSet<>();
+        private Collection<RelativeClassInfo> chain;
 
         private InheritanceChain() {
-            chain.add(RelativeClassInfo.this);
-            chain.addAll(superClasses);
         }
 
-        public Set<RelativeClassInfo> getClasses() {
+        public Collection<RelativeClassInfo> getClasses() {
+            if (chain == null) {
+                var superClasses = getSuperClasses();
+                chain = new HashSet<>(superClasses.size() + 1);
+                chain.add(RelativeClassInfo.this);
+                chain.addAll(superClasses);
+            }
+
             return chain;
         }
 
         public Stream<RelativeClassInfo> getClassesStream() {
-            return chain.stream();
+            return getClasses().stream();
         }
 
         public List<RelativeClassInfo> getDependencies() {
             return getDependenciesStream().collect(Collectors.toList());
         }
 
         public Stream<RelativeClassInfo> getDependenciesStream() {
-            return chain.stream()
+            return getClasses().stream()
                     .flatMap(RelativeClassInfo::getDependenciesStream)
                     .distinct();
         }
@@ -233,7 +260,7 @@ public List<RelativeClassInfo> getFieldDependencies() {
         }
 
         public Stream<RelativeClassInfo> getFieldDependenciesStream() {
-            return chain.stream()
+            return getClasses().stream()
                     .flatMap(RelativeClassInfo::getFieldDependenciesStream)
                     .distinct();
         }
@@ -243,8 +270,8 @@ public List<RelativeFieldInfo> getFields() {
         }
 
         public Stream<RelativeFieldInfo> getFieldsStream() {
-            return chain.stream().flatMap(RelativeClassInfo::getFieldsStream)
-                    .distinct();
+            return getClasses().stream()
+                    .flatMap(RelativeClassInfo::getFieldsStream).distinct();
         }
 
         public List<RelativeClassInfo> getInnerClassDependencies() {
@@ -253,7 +280,7 @@ public List<RelativeClassInfo> getInnerClassDependencies() {
         }
 
         public Stream<RelativeClassInfo> getInnerClassDependenciesStream() {
-            return chain.stream()
+            return getClasses().stream()
                     .flatMap(RelativeClassInfo::getInnerClassDependenciesStream)
                     .distinct();
         }
@@ -263,7 +290,7 @@ public List<RelativeClassInfo> getInnerClasses() {
         }
 
         public Stream<RelativeClassInfo> getInnerClassesStream() {
-            return chain.stream()
+            return getClasses().stream()
                     .flatMap(RelativeClassInfo::getInnerClassesStream)
                     .distinct();
         }
@@ -299,7 +326,7 @@ public <Member, RelativeMember extends Relative<?>> Stream<RelativeMember> getMe
             Objects.requireNonNull(filter);
             Objects.requireNonNull(selector);
 
-            return chain.stream().flatMap(
+            return getClasses().stream().flatMap(
                     cls -> cls.getMembersStream(selector, filter, wrapper))
                     .distinct();
         }
@@ -309,7 +336,7 @@ public List<RelativeClassInfo> getMethodDependencies() {
         }
 
         public Stream<RelativeClassInfo> getMethodDependenciesStream() {
-            return chain.stream()
+            return getClasses().stream()
                     .flatMap(RelativeClassInfo::getMethodDependenciesStream)
                     .distinct();
         }
@@ -319,8 +346,8 @@ public List<RelativeMethodInfo> getMethods() {
         }
 
         public Stream<RelativeMethodInfo> getMethodsStream() {
-            return chain.stream().flatMap(RelativeClassInfo::getMethodsStream)
-                    .distinct();
+            return getClasses().stream()
+                    .flatMap(RelativeClassInfo::getMethodsStream).distinct();
         }
     }
 }

packages/java/parser-jvm-core/src/main/java/com/vaadin/fusion/parser/core/RelativeFieldInfo.java

@@ -9,21 +9,24 @@
 
 public final class RelativeFieldInfo
         extends AbstractRelative<FieldInfo, RelativeClassInfo> {
-    private final RelativeTypeSignature type;
+    private RelativeTypeSignature type;
 
     public RelativeFieldInfo(@Nonnull FieldInfo origin,
             @Nonnull RelativeClassInfo parent) {
         super(origin, Objects.requireNonNull(parent));
-        type = RelativeTypeSignature
-                .of(origin.getTypeSignatureOrTypeDescriptor(), this);
     }
 
     @Override
     public Stream<RelativeClassInfo> getDependenciesStream() {
-        return type.getDependenciesStream();
+        return getType().getDependenciesStream();
     }
 
     public RelativeTypeSignature getType() {
+        if (type == null) {
+            type = RelativeTypeSignature
+                    .of(origin.getTypeSignatureOrTypeDescriptor(), this);
+        }
+
         return type;
     }
 }