Minor refactoring.

Author: raphw

byte-buddy-dep/src/main/java/net/bytebuddy/description/method/ParameterList.java

@@ -79,11 +79,9 @@ abstract class AbstractBase<S extends ParameterDescription> extends FilterableLi
          * {@inheritDoc}
          */
         public boolean hasExplicitMetaData() {
-            // cache the size and make sure to avoid iterators here
-            // this pattern reduces the number of allocations and also the CPU usage
             int size = size();
-            for (int i = 0; i < size; i++) {
-                ParameterDescription parameterDescription = get(i);
+            for (int index = 0; index < size; index++) { // Avoid iterator on potential hot path.
+                ParameterDescription parameterDescription = get(index);
                 if (!parameterDescription.isNamed() || !parameterDescription.hasModifiers()) {
                     return false;
                 }
@@ -95,12 +93,10 @@ public boolean hasExplicitMetaData() {
          * {@inheritDoc}
          */
         public ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(ElementMatcher<? super TypeDescription> matcher) {
-            // cache the size and make sure to avoid iterators here
-            // this pattern reduces the number of allocations and also the CPU usage
             int size = size();
             List<ParameterDescription.Token> tokens = new ArrayList<ParameterDescription.Token>(size);
-            for (int i = 0; i < size; i++) {
-                tokens.add(get(i).asToken(matcher));
+            for (int index = 0; index < size; index++) {  // Avoid iterator on potential hot path.
+                tokens.add(get(index).asToken(matcher));
             }
             return new ByteCodeElement.Token.TokenList<ParameterDescription.Token>(tokens);
         }
@@ -109,12 +105,10 @@ public ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(E
          * {@inheritDoc}
          */
         public TypeList.Generic asTypeList() {
-            // cache the size and make sure to avoid iterators here
-            // this pattern reduces the number of allocations and also the CPU usage
             int size = size();
             List<TypeDescription.Generic> types = new ArrayList<TypeDescription.Generic>(size);
-            for (int i = 0; i < size; i++) {
-                types.add(get(i).getType());
+            for (int index = 0; index < size; index++) { // Avoid iterator on potential hot path.
+                types.add(get(index).getType());
             }
             return new TypeList.Generic.Explicit(types);
         }
@@ -123,12 +117,10 @@ public TypeList.Generic asTypeList() {
          * {@inheritDoc}
          */
         public ParameterList<ParameterDescription.InDefinedShape> asDefined() {
-            // cache the size and make sure to avoid iterators here
-            // this pattern reduces the number of allocations and also the CPU usage
             int size = size();
             List<ParameterDescription.InDefinedShape> declaredForms = new ArrayList<ParameterDescription.InDefinedShape>(size);
-            for (int i = 0; i < size; i++) {
-                declaredForms.add(get(i).asDefined());
+            for (int index = 0; index < size; index++) { // Avoid iterator on potential hot path.
+                declaredForms.add(get(index).asDefined());
             }
             return new Explicit<ParameterDescription.InDefinedShape>(declaredForms);
         }
@@ -157,16 +149,16 @@ abstract class ForLoadedExecutable<T> extends AbstractBase<ParameterDescription.
         protected final T executable;
 
         /**
-         * The number of parameters of this executable.
-         * <p>
-         * It is important to cache it as calling getParameterCount() via the dispatcher has a high cost.
+         * The parameter annotation source to query.
          */
-        protected final int size;
+        protected final ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource;
 
         /**
-         * The parameter annotation source to query.
+         * The number of parameters of this executable, or -1, if the size was not yet computed. This avoids recomputation
+         * what can lead to an unreasonable performance impact if placed on a hot execution path. This field is not
+         * volatile as the result is stable and can be recomputed from different threads.
          */
-        protected final ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource;
+        private int size;
 
         /**
          * Creates a new description for a loaded executable.
@@ -176,8 +168,8 @@ abstract class ForLoadedExecutable<T> extends AbstractBase<ParameterDescription.
          */
         protected ForLoadedExecutable(T executable, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
             this.executable = executable;
-            this.size = EXECUTABLE.getParameterCount(executable);
             this.parameterAnnotationSource = parameterAnnotationSource;
+            size = -1;
         }
 
         /**
@@ -244,6 +236,9 @@ public static ParameterList<ParameterDescription.InDefinedShape> of(Method metho
          * {@inheritDoc}
          */
         public int size() {
+            if (size == -1) {
+                size = EXECUTABLE.getParameterCount(executable);
+            }
             return size;
         }
 
@@ -584,14 +579,16 @@ class TypeSubstituting extends AbstractBase<ParameterDescription.InGenericShape>
         private final List<? extends ParameterDescription> parameterDescriptions;
 
         /**
-         * The number of parameters.
+         * The visitor to apply to the parameter types before returning them.
          */
-        private final int size;
+        private final TypeDescription.Generic.Visitor<? extends TypeDescription.Generic> visitor;
 
         /**
-         * The visitor to apply to the parameter types before returning them.
+         * The number of parameters of this executable, or -1, if the size was not yet computed. This avoids recomputation
+         * what can lead to an unreasonable performance impact if placed on a hot execution path. This field is not
+         * volatile as the result is stable and can be recomputed from different threads.
          */
-        private final TypeDescription.Generic.Visitor<? extends TypeDescription.Generic> visitor;
+        private int size;
 
         /**
          * Creates a new type substituting parameter list.
@@ -605,8 +602,8 @@ public TypeSubstituting(MethodDescription.InGenericShape declaringMethod,
                                 TypeDescription.Generic.Visitor<? extends TypeDescription.Generic> visitor) {
             this.declaringMethod = declaringMethod;
             this.parameterDescriptions = parameterDescriptions;
-            this.size = parameterDescriptions.size();
             this.visitor = visitor;
+            size = -1;
         }
 
         /**
@@ -620,6 +617,9 @@ public ParameterDescription.InGenericShape get(int index) {
          * {@inheritDoc}
          */
         public int size() {
+            if (size == -1) {
+                size = parameterDescriptions.size();
+            }
             return size;
         }
     }