NPE in LocalDeclaration.resolve(LocalDeclaration.java:379)

[iloveeclipse]

1. Import JDT.UI project into the workspace and open org.eclipse.jdt.internal.ui.refactoring.reorg.ReorgMoveStarter in the editor.
2. Right click on ReorgMoveStarter.create() method and try to "Open Call Hierarchy" on it.
3. Call Hierarchy opens and shows no callers (there are some), at same time error is logged into the log, see below.
4. Same happens with the "References -> Workspace" action. Searching for the ReorgMoveStarter type references works.

java.lang.NullPointerException: Cannot read field "id" because "variableType" is null
	at org.eclipse.jdt.internal.compiler.ast.LocalDeclaration.resolve(LocalDeclaration.java:379)
	at org.eclipse.jdt.internal.compiler.ast.Statement.resolveWithBindings(Statement.java:526)
	at org.eclipse.jdt.internal.compiler.ast.ASTNode.resolveStatements(ASTNode.java:699)
	at org.eclipse.jdt.internal.compiler.ast.Block.resolve(Block.java:143)
	at org.eclipse.jdt.internal.compiler.ast.Initializer.resolve(Initializer.java:149)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1395)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1610)
	at org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve(CompilationUnitDeclaration.java:661)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.process(MatchLocator.java:2055)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatchesDefaultImpl(MatchLocator.java:1364)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1283)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1401)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1522)
	at org.eclipse.jdt.internal.core.search.JavaSearchParticipant.locateMatches(JavaSearchParticipant.java:143)
	at org.eclipse.jdt.internal.core.search.BasicSearchEngine.findMatches(BasicSearchEngine.java:279)
	at org.eclipse.jdt.internal.core.search.BasicSearchEngine.search(BasicSearchEngine.java:638)
	at org.eclipse.jdt.core.search.SearchEngine.search(SearchEngine.java:697)
	at org.eclipse.jdt.internal.corext.callhierarchy.CallerMethodWrapper.findChildren(CallerMethodWrapper.java:167)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.performSearch(MethodWrapper.java:265)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.doFindChildren(MethodWrapper.java:196)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.getCalls(MethodWrapper.java:87)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.getCalls(DeferredMethodWrapper.java:72)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.lambda$0(DeferredMethodWrapper.java:80)
	at org.eclipse.jdt.core.JavaCore.lambda$1(JavaCore.java:6233)
	at org.eclipse.jdt.internal.core.JavaModelManager.cacheZipFiles(JavaModelManager.java:5752)
	at org.eclipse.jdt.internal.core.JavaModelManager.callReadOnly(JavaModelManager.java:5741)
	at org.eclipse.jdt.core.JavaCore.callReadOnly(JavaCore.java:6217)
	at org.eclipse.jdt.core.JavaCore.runReadOnly(JavaCore.java:6232)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.fetchDeferredChildren(DeferredMethodWrapper.java:80)
	at org.eclipse.ui.progress.DeferredTreeContentManager$1.run(DeferredTreeContentManager.java:215)
	at org.eclipse.core.internal.jobs.Worker.run(Worker.java:63)

I believe it could be regression from e49ba49 / #4164, where the code above the NPE changed the variableType assignments. @srikanth-sankaran : could you please check?

[srikanth-sankaran]

I believe it could be regression from e49ba49 / #4164, where the code above the NPE changed the variableType assignments. @srikanth-sankaran : could you please check?

I am unable to reproduce this with 4.41 M2.

Call hierarchy opens listing two callers: org.eclipse.jdt.internal.ui.packageview.SelectionTransferDropAdapter.handleDropMove(Object) and org.eclipse.jdt.internal.ui.navigator.JavaDropAdapterAssistant.handleDropMove(Object)

Likewise References -> Workspace lists the same two callers.

I'll check if there was a recent fix that may have solved the problem

[srikanth-sankaran]

Looking into the code for the method org.eclipse.jdt.internal.ui.refactoring.reorg.ReorgMoveStarter.create(IJavaElement[], IResource[], IReorgDestination) it looks unlikely that e49ba49 / #4164 may be involved as this code doesn't have any var typed local variables to trigger Local Variable Type Inference which is the theme of that commit.

@iloveeclipse - do you recall what version you were on ? Any hints/clues to reproduce ? TIA

[srikanth-sankaran]

FWIW, I tried importing jdt.ui as both source project and binary project and can't see the problem in either

[iloveeclipse]

do you recall what version you were on ? Any hints/clues to reproduce ?

I see it in latest nightly SDK build too. Same steps, same error.
Stack as of today's nightly build:

eclipse.buildId=4.41.0.I20260726-2300
java.version=25
java.vendor=Eclipse Adoptium
BootLoader constants: OS=linux, ARCH=x86_64, WS=gtk, NL=en_US
Command-line arguments:  -os linux -ws gtk -arch x86_64 -data /data/4x_platform_workspace

org.eclipse.jdt.ui
Error
Mon Jul 27 10:52:18 CEST 2026
Internal Error

java.lang.NullPointerException: Cannot read field "id" because "variableType" is null
	at org.eclipse.jdt.internal.compiler.ast.LocalDeclaration.resolve(LocalDeclaration.java:379)
	at org.eclipse.jdt.internal.compiler.ast.Statement.resolveWithBindings(Statement.java:526)
	at org.eclipse.jdt.internal.compiler.ast.ASTNode.resolveStatements(ASTNode.java:699)
	at org.eclipse.jdt.internal.compiler.ast.Block.resolve(Block.java:143)
	at org.eclipse.jdt.internal.compiler.ast.Initializer.resolve(Initializer.java:149)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1395)
	at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1610)
	at org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve(CompilationUnitDeclaration.java:661)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.process(MatchLocator.java:2055)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatchesDefaultImpl(MatchLocator.java:1364)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1283)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1401)
	at org.eclipse.jdt.internal.core.search.matching.MatchLocator.locateMatches(MatchLocator.java:1522)
	at org.eclipse.jdt.internal.core.search.JavaSearchParticipant.locateMatches(JavaSearchParticipant.java:143)
	at org.eclipse.jdt.internal.core.search.BasicSearchEngine.findMatches(BasicSearchEngine.java:279)
	at org.eclipse.jdt.internal.core.search.BasicSearchEngine.search(BasicSearchEngine.java:638)
	at org.eclipse.jdt.core.search.SearchEngine.search(SearchEngine.java:697)
	at org.eclipse.jdt.internal.corext.callhierarchy.CallerMethodWrapper.findChildren(CallerMethodWrapper.java:167)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.performSearch(MethodWrapper.java:265)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.doFindChildren(MethodWrapper.java:196)
	at org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper.getCalls(MethodWrapper.java:87)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.getCalls(DeferredMethodWrapper.java:72)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.lambda$0(DeferredMethodWrapper.java:80)
	at org.eclipse.jdt.core.JavaCore.lambda$1(JavaCore.java:6233)
	at org.eclipse.jdt.internal.core.JavaModelManager.cacheZipFiles(JavaModelManager.java:5752)
	at org.eclipse.jdt.internal.core.JavaModelManager.callReadOnly(JavaModelManager.java:5741)
	at org.eclipse.jdt.core.JavaCore.callReadOnly(JavaCore.java:6217)
	at org.eclipse.jdt.core.JavaCore.runReadOnly(JavaCore.java:6232)
	at org.eclipse.jdt.internal.ui.callhierarchy.DeferredMethodWrapper.fetchDeferredChildren(DeferredMethodWrapper.java:80)
	at org.eclipse.ui.progress.DeferredTreeContentManager$1.run(DeferredTreeContentManager.java:215)
	at org.eclipse.core.internal.jobs.Worker.run(Worker.java:63)

[srikanth-sankaran]

Looking into the code for the method org.eclipse.jdt.internal.ui.refactoring.reorg.ReorgMoveStarter.create(IJavaElement[], IResource[], IReorgDestination) it looks unlikely that

Actually, ignore that - that is a completely worthless observation. It is whether potential call sites trigger LVTI is the question not whether the method on which call hierarchy/reference search is invoked uses LVTI. The latter is immaterial.

On Version: 2026-09 (4.41)
Build id: I20260726-2300

Despite importing all projects from the SDK and attempting the operations I don't see the problem.

@iloveeclipse - you can help in two ways:

1. You can try what I am trying: Start with On Version: 2026-09 (4.41) Build id: I20260726-2300 on a clean workspace, import all projects and then see if you observe the problem. And additionally/alternately in the setup you are able to reproduce ...
2. You can set org.eclipse.jdt.internal.core.search.BasicSearchEngine.VERBOSE to true to turn on some logging messages that could tell us which source file triggers that NPE and we can see which plugin is needed to reproduce.

[srikanth-sankaran]

And a third option, is to trigger the reproducing scenario under the debugger, then you can actually grab the offending source code from the frame org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration.resolve(CompilationUnitDeclaration.java:661) and see if that fails as a standalone test case.

[iloveeclipse]

The problem doesn't appear in a new workspace.
In the old workspace error disappears if I remove External Plug-in Libraries project (hidden by default in package Explorer) and restart.
However, after executing PDE command "Add all plugins to Java workspace scope" via Ctrl+3 the problem appears again.

[iloveeclipse]

Starting Eclipse from Eclipse and setting the tracing up I see:

| Worker-19: Fetching children of create | 2026-07-27 13:10:45.667 | org.eclipse.jdt.core | /debug | org.eclipse.jdt.internal.core.search.matching.MatchLocator | process | 2045 | Resolving IntrospectionHelper$Creator.class [in org.apache.tools.ant [in /data2/SDK/eclipse4.41/eclipse/plugins/org.apache.ant_1.10.17.v20260410-1000/lib/ant.jar]] |

!ENTRY org.eclipse.jdt.ui 4 10001 2026-07-27 13:10:45.678
!MESSAGE Internal Error
!STACK 0
java.lang.NullPointerException: Cannot read field "id" because "variableType" is null
	at org.eclipse.jdt.internal.compiler.ast.LocalDeclaration.resolve(LocalDeclaration.java:379)

The unit in question is at line 2045 in org.eclipse.jdt.internal.core.search.matching.MatchLocator.process(PossibleMatch, boolean)

package org.apache.tools.ant;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.function.Supplier;
import org.apache.tools.ant.taskdefs.PreSetDef;
import org.apache.tools.ant.types.EnumeratedAttribute;
import org.apache.tools.ant.types.Resource;
import org.apache.tools.ant.types.resources.FileProvider;
import org.apache.tools.ant.types.resources.FileResource;
import org.apache.tools.ant.util.StringUtils;
/**
   * @see #getHelper(Project , Class )
 */
public final class IntrospectionHelper {
  /**
   */
  public static final class Creator {
    private final NestedCreator nestedCreator;
    private final Object parent;
    private final Project project;
    private Object nestedObject;
    private String polyType;
    /**
       * @param     project
       * @param     parent
       * @param     nestedCreator
     */
    private Creator(final Project project, final Object parent, final NestedCreator nestedCreator) {
      super();
      this.project = project;
      this.parent = parent;
      this.nestedCreator = nestedCreator;
    }
    /**
       * @param     polyType
     */
    public void setPolyType(final String polyType) {
      this.polyType = polyType;
    }
    /**
       * @    return  <not empty>
     */
    public Object create() {
      if ((polyType != null))
          {
            if ((! nestedCreator.isPolyMorphic()))
                {
                  throw new BuildException("Not allowed to use the polymorphic form for this element");
                }
            final ComponentHelper helper = ComponentHelper.getComponentHelper(project);
            nestedObject = helper.createComponent(polyType);
            if ((nestedObject == null))
                {
                  throw new BuildException(("Unable to create object of type " + polyType));
                }
          }
      try
        {
          nestedObject = nestedCreator.create(project, parent, nestedObject);
          if ((project != null))
              {
                project.setProjectReference(nestedObject);
              }
          return nestedObject;
        }
      catch (final IllegalAccessException | InstantiationException ex)
        {
          throw new BuildException(ex);
        }
      catch (final IllegalArgumentException ex)
        {
          if ((polyType == null))
              {
                throw ex;
              }
          throw new BuildException(("Invalid type used " + polyType));
        }
      catch (final InvocationTargetException ex)
        {
          throw extractBuildException(ex);
        }
    }
    /**
       * @    return  <not empty>
     */
    public Object getRealObject() {
      return nestedCreator.getRealObject();
    }
    /**
     */
    public void store() {
      try
        {
          nestedCreator.store(parent, nestedObject);
        }
      catch (final IllegalAccessException | InstantiationException ex)
        {
          throw new BuildException(ex);
        }
      catch (final IllegalArgumentException ex)
        {
          if ((polyType == null))
              {
                throw ex;
              }
          throw new BuildException(("Invalid type used " + polyType));
        }
      catch (final InvocationTargetException ex)
        {
          throw extractBuildException(ex);
        }
    }
  }
  /**
   */
  private static abstract class NestedCreator {
    private final Method method;
    protected NestedCreator(final Method m) {
      super();
      method = m;
    }
    Method getMethod() {
      return method;
    }
    boolean isPolyMorphic() {
      return false;
    }
    Object getRealObject() {
      return null;
    }
    abstract Object create(Project project, Object parent, Object child) throws InvocationTargetException, IllegalAccessException, InstantiationException;
    void store(final Object parent, final Object child) throws InvocationTargetException, IllegalAccessException, InstantiationException {
    }
  }
  private static class CreateNestedCreator extends NestedCreator {
    CreateNestedCreator(final Method m) {
      super(m);
    }
    @Override Object create(final Project project, final Object parent, final Object ignore) throws InvocationTargetException, IllegalAccessException {
      return getMethod().invoke(parent);
    }
  }
  /**
   */
  private static class AddNestedCreator extends NestedCreator {
    static final int ADD = 1;
    static final int ADD_CONFIGURED = 2;
    private final Constructor<?> constructor;
    private final int behavior;
    <clinit>() {
    }
    AddNestedCreator(final Method m, final Constructor<?> c, final int behavior) {
      super(m);
      this.constructor = c;
      this.behavior = behavior;
    }
    @Override boolean isPolyMorphic() {
      return true;
    }
    @Override Object create(final Project project, final Object parent, Object child) throws InvocationTargetException, IllegalAccessException, InstantiationException {
      if ((child == null))
          {
            child = constructor.newInstance(((constructor.getParameterTypes().length == 0) ? new Object[]{} : new Object[]{project}));
          }
      if ((child instanceof PreSetDef.PreSetDefinition))
          {
            child = ((PreSetDef.PreSetDefinition) child).createObject(project);
          }
      if ((behavior == ADD))
          {
            istore(parent, child);
          }
      return child;
    }
    @Override void store(final Object parent, final Object child) throws InvocationTargetException, IllegalAccessException, InstantiationException {
      if ((behavior == ADD_CONFIGURED))
          {
            istore(parent, child);
          }
    }
    private void istore(final Object parent, final Object child) throws InvocationTargetException, IllegalAccessException {
      getMethod().invoke(parent, child);
    }
  }
  /**
   */
  private static abstract class AttributeSetter {
    private final Method method;
    private final Class<?> type;
    private final Supplier<?> supplyWhenNull;
    protected AttributeSetter(final Method m, final Class<?> type) {
      this(m, type, () -> null);
    }
    protected AttributeSetter(final Method method, final Class<?> type, final Supplier<?> supplyWhenNull) {
      super();
      this.method = method;
      this.type = type;
      this.supplyWhenNull = supplyWhenNull;
    }
    final void setObject(final Project p, final Object parent, Object value) throws InvocationTargetException, IllegalAccessException, BuildException {
      if ((type != null))
          {
            Class<?> useType = type;
            if (type.isPrimitive())
                {
                  if ((value == null))
                      {
                        throw new BuildException("Attempt to set primitive %s to null on %s", getPropertyName(method.getName(), "set"), parent);
                      }
                  useType = PRIMITIVE_TYPE_MAP.get(type);
                }
            if ((value == null))
                {
                  value = supplyWhenNull.get();
                }
            if (((value == null) || useType.isInstance(value)))
                {
                  method.invoke(parent, value);
                  return;
                }
          }
      method.invoke(parent, toTargetType(p, value.toString()));
    }
    Object toTargetType(Project project, String value) {
      throw new UnsupportedOperationException();
    }
  }
  private static class MethodAndObject {
    private final Method method;
    private final Object object;
    public MethodAndObject(final Method method, final Object object) {
      super();
      this.method = method;
      this.object = object;
    }
  }
  /**
   */
  private static final Map<String, IntrospectionHelper> HELPERS = new Hashtable<>();
  /**
   */
  private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_MAP = new HashMap<>(8);
  static {
    final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
    final Class<?>[] wrappers = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class};
    for (int i = 0;; (i < primitives.length); i ++) 
      {
        PRIMITIVE_TYPE_MAP.put(primitives[i], wrappers[i]);
      }
  }
  private static final int MAX_REPORT_NESTED_TEXT = 20;
  private static final String ELLIPSIS = "...";
  /**
   */
  private final Map<String, Class<?>> attributeTypes = new Hashtable<>();
  /**
   */
  private final Map<String, AttributeSetter> attributeSetters = new Hashtable<>();
  /**
   */
  private final Map<String, Class<?>> nestedTypes = new Hashtable<>();
  /**
   */
  private final Map<String, NestedCreator> nestedCreators = new Hashtable<>();
  /**
   */
  private final List<Method> addTypeMethods = new ArrayList<>();
  /**
   */
  private final Method addText;
  /**
   */
  private final Class<?> bean;
  /**
     * @see   #throwNotSupported
   */
  protected static final String NOT_SUPPORTED_CHILD_PREFIX = " doesn't support the nested \"";
  /**
     * @see   #throwNotSupported
   */
  protected static final String NOT_SUPPORTED_CHILD_POSTFIX = "\" element.";
  <clinit>() {
  }
  /**
     * @param   bean
     * @see   #getHelper(Class )
     * @see   #getHelper(Class )
   */
  private IntrospectionHelper(final Class<?> bean) {
    super();
    this.bean = bean;
    Method addTextMethod = null;
    for (final Method m : bean.getMethods()) 
      {
        final String name = m.getName();
        final Class<?> returnType = m.getReturnType();
        final Class<?>[] args = m.getParameterTypes();
        if ((((args.length == 1) && Void.TYPE.equals(returnType)) && ("add".equals(name) || "addConfigured".equals(name))))
            {
              insertAddTypeMethod(m);
              continue ;
            }
        if (((ProjectComponent.class.isAssignableFrom(bean) && (args.length == 1)) && isHiddenSetMethod(name, args[0])))
            {
              continue ;
            }
        if ((((isContainer() && (args.length == 1)) && "addTask".equals(name)) && Task.class.equals(args[0])))
            {
              continue ;
            }
        if (((("addText".equals(name) && Void.TYPE.equals(returnType)) && (args.length == 1)) && String.class.equals(args[0])))
            {
              addTextMethod = m;
            }
        else
            if ((((name.startsWith("set") && Void.TYPE.equals(returnType)) && (args.length == 1)) && (! args[0].isArray())))
                {
                  final String propName = getPropertyName(name, "set");
                  AttributeSetter as = attributeSetters.get(propName);
                  if ((as != null))
                      {
                        if (String.class.equals(args[0]))
                            {
                              continue ;
                            }
                        if (File.class.equals(args[0]))
                            {
                              if ((Resource.class.equals(as.type) || FileProvider.class.equals(as.type)))
                                  {
                                    continue ;
                                  }
                            }
                      }
                  as = createAttributeSetter(m, args[0], propName);
                  if ((as != null))
                      {
                        attributeTypes.put(propName, args[0]);
                        attributeSetters.put(propName, as);
                      }
                }
            else
                if ((((name.startsWith("create") && (! returnType.isArray())) && (! returnType.isPrimitive())) && (args.length == 0)))
                    {
                      final String propName = getPropertyName(name, "create");
                      if ((nestedCreators.get(propName) == null))
                          {
                            nestedTypes.put(propName, returnType);
                            nestedCreators.put(propName, new CreateNestedCreator(m));
                          }
                    }
                else
                    if ((((((name.startsWith("addConfigured") && Void.TYPE.equals(returnType)) && (args.length == 1)) && (! String.class.equals(args[0]))) && (! args[0].isArray())) && (! args[0].isPrimitive())))
                        {
                          try
                            {
                              Constructor<?> constructor = null;
                              try
                                {
                                  constructor = args[0].getConstructor();
                                }
                              catch (final NoSuchMethodException ex)
                                {
                                  constructor = args[0].getConstructor(Project.class);
                                }
                              final String propName = getPropertyName(name, "addConfigured");
                              nestedTypes.put(propName, args[0]);
                              nestedCreators.put(propName, new AddNestedCreator(m, constructor, AddNestedCreator.ADD_CONFIGURED));
                            }
                          catch (final NoSuchMethodException nse)
                            {
                            }
                        }
                    else
                        if ((((((name.startsWith("add") && Void.TYPE.equals(returnType)) && (args.length == 1)) && (! String.class.equals(args[0]))) && (! args[0].isArray())) && (! args[0].isPrimitive())))
                            {
                              try
                                {
                                  Constructor<?> constructor = null;
                                  try
                                    {
                                      constructor = args[0].getConstructor();
                                    }
                                  catch (final NoSuchMethodException ex)
                                    {
                                      constructor = args[0].getConstructor(Project.class);
                                    }
                                  final String propName = getPropertyName(name, "add");
                                  if ((nestedTypes.get(propName) != null))
                                      {
                                        continue ;
                                      }
                                  nestedTypes.put(propName, args[0]);
                                  nestedCreators.put(propName, new AddNestedCreator(m, constructor, AddNestedCreator.ADD));
                                }
                              catch (final NoSuchMethodException nse)
                                {
                                }
                            }
      }
    addText = addTextMethod;
  }
  /**
     * @param   name
     * @param   type
     * @  return  <not empty>
   */
  private boolean isHiddenSetMethod(final String name, final Class<?> type) {
    return (("setLocation".equals(name) && Location.class.equals(type)) || ("setTaskType".equals(name) && String.class.equals(type)));
  }
  /**
     * @param   c
     * @  return  <not empty>
   */
  public static IntrospectionHelper getHelper(final Class<?> c) {
    return getHelper(null, c);
  }
  /**
     * @param   p
     * @param   c
     * @  return  <not empty>
   */
  public static IntrospectionHelper getHelper(final Project p, final Class<?> c) {
    if ((p == null))
        {
          return new IntrospectionHelper(c);
        }
    IntrospectionHelper ih = HELPERS.get(c.getName());
    if (((ih != null) && (ih.bean == c)))
        {
          return ih;
        }
    ih = new IntrospectionHelper(c);
    synchronized (HELPERS)
      {
        IntrospectionHelper cached = HELPERS.get(c.getName());
        if (((cached != null) && (cached.bean == c)))
            {
              return cached;
            }
        HELPERS.put(c.getName(), ih);
        return ih;
      }
  }
  /**
     * @param   p
     * @param   element
     * @param   attributeName
     * @param   value
     * @throws   BuildException
   */
  public void setAttribute(final Project p, final Object element, final String attributeName, final Object value) throws BuildException {
    final AttributeSetter as = attributeSetters.get(attributeName.toLowerCase(Locale.ENGLISH));
    if (((as == null) && (value != null)))
        {
          if ((element instanceof DynamicAttributeNS))
              {
                final DynamicAttributeNS dc = (DynamicAttributeNS) element;
                final String uriPlusPrefix = ProjectHelper.extractUriFromComponentName(attributeName);
                final String uri = ProjectHelper.extractUriFromComponentName(uriPlusPrefix);
                final String localName = ProjectHelper.extractNameFromComponentName(attributeName);
                final String qName = (uri.isEmpty() ? localName : ((uri + ":") + localName));
                dc.setDynamicAttribute(uri, localName, qName, value.toString());
                return;
              }
          if ((element instanceof DynamicObjectAttribute))
              {
                final DynamicObjectAttribute dc = (DynamicObjectAttribute) element;
                dc.setDynamicAttribute(attributeName.toLowerCase(Locale.ENGLISH), value);
                return;
              }
          if ((element instanceof DynamicAttribute))
              {
                final DynamicAttribute dc = (DynamicAttribute) element;
                dc.setDynamicAttribute(attributeName.toLowerCase(Locale.ENGLISH), value.toString());
                return;
              }
          if (attributeName.contains(":"))
              {
                return;
              }
          final String msg = (((getElementName(p, element) + " doesn't support the \"") + attributeName) + "\" attribute.");
          throw new UnsupportedAttributeException(msg, attributeName);
        }
    if ((as != null))
        {
          try
            {
              as.setObject(p, element, value);
            }
          catch (final IllegalAccessException ie)
            {
              throw new BuildException(ie);
            }
          catch (final InvocationTargetException ite)
            {
              throw extractBuildException(ite);
            }
        }
  }
  /**
     * @param   p
     * @param   element
     * @param   attributeName
     * @param   value
     * @throws   BuildException
   */
  public void setAttribute(final Project p, final Object element, final String attributeName, final String value) throws BuildException {
    setAttribute(p, element, attributeName, (Object) value);
  }
  /**
     * @param   project
     * @param   element
     * @param   text
     * @throws   BuildException
   */
  public void addText(final Project project, final Object element, String text) throws BuildException {
    if ((addText == null))
        {
          text = text.trim();
          if (text.isEmpty())
              {
                return;
              }
          throw new BuildException((((project.getElementName(element) + " doesn't support nested text data (\"") + condenseText(text)) + "\")."));
        }
    try
      {
        addText.invoke(element, text);
      }
    catch (final IllegalAccessException ie)
      {
        throw new BuildException(ie);
      }
    catch (final InvocationTargetException ite)
      {
        throw extractBuildException(ite);
      }
  }
  /**
     * @param   project
     * @param   parent
     * @param   elementName
   */
  public void throwNotSupported(final Project project, final Object parent, final String elementName) {
    final String msg = (((project.getElementName(parent) + NOT_SUPPORTED_CHILD_PREFIX) + elementName) + NOT_SUPPORTED_CHILD_POSTFIX);
    throw new UnsupportedElementException(msg, elementName);
  }
  /**
     * @param   project
     * @param   parentUri
     * @param   parent
     * @param   elementName
     * @param   child
     * @  return  <not empty>
     * @throws   BuildException
   */
  private NestedCreator getNestedCreator(final Project project, String parentUri, final Object parent, final String elementName, final UnknownElement child) throws BuildException {
    String uri = ProjectHelper.extractUriFromComponentName(elementName);
    final String name = ProjectHelper.extractNameFromComponentName(elementName);
    if (uri.equals(ProjectHelper.ANT_CORE_URI))
        {
          uri = "";
        }
    if (parentUri.equals(ProjectHelper.ANT_CORE_URI))
        {
          parentUri = "";
        }
    NestedCreator nc = null;
    if ((uri.equals(parentUri) || uri.isEmpty()))
        {
          nc = nestedCreators.get(name.toLowerCase(Locale.ENGLISH));
        }
    if ((nc == null))
        {
          nc = createAddTypeCreator(project, parent, elementName);
        }
    if (((nc == null) && ((parent instanceof DynamicElementNS) || (parent instanceof DynamicElement))))
        {
          final String qName = ((child == null) ? name : child.getQName());
          final Object nestedElement = createDynamicElement(parent, ((child == null) ? "" : child.getNamespace()), name, qName);
          if ((nestedElement != null))
              {
                nc = new NestedCreator(null) {
  @Override Object create(final Project project, final Object parent, final Object ignore) {
    return nestedElement;
  }
};
              }
        }
    if ((nc == null))
        {
          throwNotSupported(project, parent, elementName);
        }
    return nc;
  }
  /**
   */
  private Object createDynamicElement(final Object parent, final String ns, final String localName, final String qName) {
    Object nestedElement = null;
    if ((parent instanceof DynamicElementNS))
        {
          final DynamicElementNS dc = (DynamicElementNS) parent;
          nestedElement = dc.createDynamicElement(ns, localName, qName);
        }
    if (((nestedElement == null) && (parent instanceof DynamicElement)))
        {
          final DynamicElement dc = (DynamicElement) parent;
          nestedElement = dc.createDynamicElement(localName.toLowerCase(Locale.ENGLISH));
        }
    return nestedElement;
  }
  /**
     * @param   project
     * @param   parent
     * @param   elementName
     * @  return  <not empty>
     * @throws   BuildException
   */
  public @Deprecated Object createElement(final Project project, final Object parent, final String elementName) throws BuildException {
    final NestedCreator nc = getNestedCreator(project, "", parent, elementName, null);
    try
      {
        final Object nestedElement = nc.create(project, parent, null);
        if ((project != null))
            {
              project.setProjectReference(nestedElement);
            }
        return nestedElement;
      }
    catch (final IllegalAccessException | InstantiationException ie)
      {
        throw new BuildException(ie);
      }
    catch (final InvocationTargetException ite)
      {
        throw extractBuildException(ite);
      }
  }
  /**
     * @param   project
     * @param   parentUri
     * @param   parent
     * @param   elementName
     * @param   ue
     * @  return  <not empty>
   */
  public Creator getElementCreator(final Project project, final String parentUri, final Object parent, final String elementName, final UnknownElement ue) {
    final NestedCreator nc = getNestedCreator(project, parentUri, parent, elementName, ue);
    return new Creator(project, parent, nc);
  }
  /**
     * @  return  <not empty>
     * @see   DynamicElement
     * @see   DynamicElementNS
   */
  public boolean isDynamic() {
    return (DynamicElement.class.isAssignableFrom(bean) || DynamicElementNS.class.isAssignableFrom(bean));
  }
  /**
     * @  return  <not empty>
     * @see   TaskContainer
   */
  public boolean isContainer() {
    return TaskContainer.class.isAssignableFrom(bean);
  }
  /**
     * @param   elementName
     * @  return  <not empty>
   */
  public boolean supportsNestedElement(final String elementName) {
    return supportsNestedElement("", elementName);
  }
  /**
     * @param   parentUri
     * @param   elementName
     * @  return  <not empty>
     * @see   #isDynamic
   */
  public boolean supportsNestedElement(final String parentUri, final String elementName) {
    return ((isDynamic() || (! addTypeMethods.isEmpty())) || supportsReflectElement(parentUri, elementName));
  }
  /**
     * @param   parentUri
     * @param   elementName
     * @param   project
     * @param   parent
     * @  return  <not empty>
     * @see   #isDynamic
     * @see   #getElementCreator
   */
  public boolean supportsNestedElement(final String parentUri, final String elementName, final Project project, final Object parent) {
    return ((((! addTypeMethods.isEmpty()) && (createAddTypeCreator(project, parent, elementName) != null)) || isDynamic()) || supportsReflectElement(parentUri, elementName));
  }
  /**
     * @param   parentUri
     * @param   elementName
     * @  return  <not empty>
   */
  public boolean supportsReflectElement(String parentUri, final String elementName) {
    final String name = ProjectHelper.extractNameFromComponentName(elementName);
    if ((! nestedCreators.containsKey(name.toLowerCase(Locale.ENGLISH))))
        {
          return false;
        }
    String uri = ProjectHelper.extractUriFromComponentName(elementName);
    if ((uri.equals(ProjectHelper.ANT_CORE_URI) || uri.isEmpty()))
        {
          return true;
        }
    if (parentUri.equals(ProjectHelper.ANT_CORE_URI))
        {
          parentUri = "";
        }
    return uri.equals(parentUri);
  }
  /**
     * @param   project
     * @param   parent
     * @param   child
     * @param   elementName
     * @throws   BuildException
   */
  public void storeElement(final Project project, final Object parent, final Object child, final String elementName) throws BuildException {
    if ((elementName == null))
        {
          return;
        }
    final NestedCreator ns = nestedCreators.get(elementName.toLowerCase(Locale.ENGLISH));
    if ((ns == null))
        {
          return;
        }
    try
      {
        ns.store(parent, child);
      }
    catch (final IllegalAccessException | InstantiationException ie)
      {
        throw new BuildException(ie);
      }
    catch (final InvocationTargetException ite)
      {
        throw extractBuildException(ite);
      }
  }
  /**
     * @param   ite
     * @  return  <not empty>
     * @see   InvocationTargetException
   */
  private static BuildException extractBuildException(final InvocationTargetException ite) {
    final Throwable t = ite.getTargetException();
    if ((t instanceof BuildException))
        {
          return (BuildException) t;
        }
    return new BuildException(t);
  }
  /**
     * @param   elementName
     * @  return  <not empty>
     * @throws   BuildException
   */
  public Class<?> getElementType(final String elementName) throws BuildException {
    final Class<?> nt = nestedTypes.get(elementName);
    if ((nt == null))
        {
          throw new UnsupportedElementException((((("Class " + bean.getName()) + " doesn't support the nested \"") + elementName) + "\" element."), elementName);
        }
    return nt;
  }
  /**
     * @param   attributeName
     * @  return  <not empty>
     * @throws   BuildException
   */
  public Class<?> getAttributeType(final String attributeName) throws BuildException {
    final Class<?> at = attributeTypes.get(attributeName);
    if ((at == null))
        {
          throw new UnsupportedAttributeException((((("Class " + bean.getName()) + " doesn't support the \"") + attributeName) + "\" attribute."), attributeName);
        }
    return at;
  }
  /**
     * @  return  <not empty>
     * @throws   BuildException
   */
  public Method getAddTextMethod() throws BuildException {
    if ((! supportsCharacters()))
        {
          throw new BuildException((("Class " + bean.getName()) + " doesn't support nested text data."));
        }
    return addText;
  }
  /**
     * @param   elementName
     * @  return  <not empty>
     * @throws   BuildException
   */
  public Method getElementMethod(final String elementName) throws BuildException {
    final NestedCreator creator = nestedCreators.get(elementName);
    if ((creator == null))
        {
          throw new UnsupportedElementException((((("Class " + bean.getName()) + " doesn't support the nested \"") + elementName) + "\" element."), elementName);
        }
    return creator.method;
  }
  /**
     * @param   attributeName
     * @  return  <not empty>
     * @throws   BuildException
   */
  public Method getAttributeMethod(final String attributeName) throws BuildException {
    final AttributeSetter setter = attributeSetters.get(attributeName);
    if ((setter == null))
        {
          throw new UnsupportedAttributeException((((("Class " + bean.getName()) + " doesn't support the \"") + attributeName) + "\" attribute."), attributeName);
        }
    return setter.method;
  }
  /**
     * @  return  <not empty>
   */
  public boolean supportsCharacters() {
    return (addText != null);
  }
  /**
     * @  return  <not empty>
     * @see   #getAttributeMap
   */
  public Enumeration<String> getAttributes() {
    return Collections.enumeration(attributeSetters.keySet());
  }
  /**
     * @  return  <not empty>
   */
  public Map<String, Class<?>> getAttributeMap() {
    return (attributeTypes.isEmpty() ? Collections.emptyMap() : Collections.unmodifiableMap(attributeTypes));
  }
  /**
     * @  return  <not empty>
     * @see   #getNestedElementMap
   */
  public Enumeration<String> getNestedElements() {
    return Collections.enumeration(nestedTypes.keySet());
  }
  /**
     * @  return  <not empty>
   */
  public Map<String, Class<?>> getNestedElementMap() {
    return (nestedTypes.isEmpty() ? Collections.emptyMap() : Collections.unmodifiableMap(nestedTypes));
  }
  /**
     * @  return  <not empty>
   */
  public List<Method> getExtensionPoints() {
    return (addTypeMethods.isEmpty() ? Collections.emptyList() : Collections.unmodifiableList(addTypeMethods));
  }
  /**
     * @param   m
     * @param   arg
     * @param   attrName
     * @  return  <not empty>
     * @see   Project#toBoolean(String )
     * @see   EnumeratedAttribute#setValue(String )
   */
  private AttributeSetter createAttributeSetter(final Method m, final Class<?> arg, final String attrName) {
    if (Optional.class.equals(arg))
        {
          Type gpt = m.getGenericParameterTypes()[0];
          Class<?> payload = Object.class;
          if ((gpt instanceof ParameterizedType))
              {
                Type ata = ((ParameterizedType) gpt).getActualTypeArguments()[0];
                if ((ata instanceof Class<?>))
                    {
                      payload = (Class<?>) ata;
                    }
                else
                    if ((ata instanceof ParameterizedType))
                        {
                          payload = (Class<?>) ((ParameterizedType) ata).getRawType();
                        }
              }
          final AttributeSetter wrapped = createAttributeSetter(m, payload, attrName);
          return new AttributeSetter(m, arg, Optional::empty) {
  @Override Optional<?> toTargetType(Project project, String value) throws BuildException {
    return Optional.ofNullable(wrapped.toTargetType(project, value));
  }
};
        }
    if (OptionalInt.class.equals(arg))
        {
          final AttributeSetter wrapped = createAttributeSetter(m, Integer.class, attrName);
          return new AttributeSetter(m, arg, OptionalInt::empty) {
  @Override OptionalInt toTargetType(Project project, String value) throws BuildException {
    return Optional.ofNullable((Integer) wrapped.toTargetType(project, value)).map(OptionalInt::of).orElseGet(OptionalInt::empty);
  }
};
        }
    if (OptionalLong.class.equals(arg))
        {
          final AttributeSetter wrapped = createAttributeSetter(m, Long.class, attrName);
          return new AttributeSetter(m, arg, OptionalLong::empty) {
  @Override OptionalLong toTargetType(Project project, String value) throws BuildException {
    return Optional.ofNullable((Long) wrapped.toTargetType(project, value)).map(OptionalLong::of).orElseGet(OptionalLong::empty);
  }
};
        }
    if (OptionalDouble.class.equals(arg))
        {
          final AttributeSetter wrapped = createAttributeSetter(m, Double.class, attrName);
          return new AttributeSetter(m, arg, OptionalDouble::empty) {
  @Override Object toTargetType(Project project, String value) throws BuildException {
    return Optional.ofNullable((Double) wrapped.toTargetType(project, value)).map(OptionalDouble::of).orElseGet(OptionalDouble::empty);
  }
};
        }
    final Class<?> reflectedArg = PRIMITIVE_TYPE_MAP.getOrDefault(arg, arg);
    if ((Object.class == reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  @Override Object toTargetType(Project project, String value) throws BuildException {
    throw new BuildException("Internal ant problem - this should not get called");
  }
};
        }
    if (String.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override String toTargetType(Project project, String t) {
    return t;
  }
};
        }
    if (Character.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override Character toTargetType(Project project, String value) {
    if (value.isEmpty())
        {
          throw new BuildException(((ExtendedStringLiteral{The value "" is not a legal value for attribute "} + attrName) + "\""));
        }
    return Character.valueOf(value.charAt(0));
  }
};
        }
    if (Boolean.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override Boolean toTargetType(Project project, String value) {
    return Boolean.valueOf(Project.toBoolean(value));
  }
};
        }
    if (Class.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override Class<?> toTargetType(Project project, String value) {
    try
      {
        return Class.forName(value);
      }
    catch (ClassNotFoundException e)
      {
        throw new BuildException(e);
      }
  }
};
        }
    if (File.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  @Override Object toTargetType(Project project, String value) throws BuildException {
    return project.resolveFile(value);
  }
};
        }
    if (java.nio.file.Path.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  @Override Object toTargetType(Project project, String value) throws BuildException {
    return project.resolveFile(value).toPath();
  }
};
        }
    if ((Resource.class.equals(reflectedArg) || FileProvider.class.equals(reflectedArg)))
        {
          return new AttributeSetter(m, arg) {
  @Override Object toTargetType(Project project, String value) throws BuildException {
    return new FileResource(project.resolveFile(value));
  }
};
        }
    if (EnumeratedAttribute.class.isAssignableFrom(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override EnumeratedAttribute toTargetType(Project project, String value) {
    EnumeratedAttribute ea;
    try
      {
        ea = (EnumeratedAttribute) reflectedArg.getDeclaredConstructor().newInstance();
      }
    catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e)
      {
        throw BuildException.of(e);
      }
    ea.setValue(value);
    return ea;
  }
};
        }
    final AttributeSetter setter = getEnumSetter(reflectedArg, m, arg);
    if ((setter != null))
        {
          return setter;
        }
    if (Long.class.equals(reflectedArg))
        {
          return new AttributeSetter(m, arg) {
  public @Override Long toTargetType(Project project, String value) {
    try
      {
        return Long.valueOf(StringUtils.parseHumanSizes(value));
      }
    catch (final NumberFormatException e)
      {
        throw new BuildException(String.format("Can't assign non-numeric value '%s' to attribute %s", value, attrName));
      }
    catch (final Exception e)
      {
        throw new BuildException(e);
      }
  }
};
        }
    boolean includeProject;
    Constructor<?> c;
    try
      {
        c = reflectedArg.getConstructor(Project.class, String.class);
        includeProject = true;
      }
    catch (final NoSuchMethodException nme)
      {
        try
          {
            c = reflectedArg.getConstructor(String.class);
            includeProject = false;
          }
        catch (final NoSuchMethodException nme2)
          {
            return null;
          }
      }
    final boolean finalIncludeProject = includeProject;
    final Constructor<?> finalConstructor = c;
    return new AttributeSetter(m, arg) {
  public @Override Object toTargetType(Project project, String value) {
    try
      {
        final Object[] args = (finalIncludeProject ? new Object[]{project, value} : new Object[]{value});
        final Object attribute = finalConstructor.newInstance(args);
        if ((project != null))
            {
              project.setProjectReference(attribute);
            }
        return attribute;
      }
    catch (final Exception e)
      {
        Throwable thw = e;
        while (true)          {
            if ((thw instanceof IllegalArgumentException))
                {
                  throw new BuildException(String.format("Can't convert value '%s' to type %s, reason: %s with message '%s'", value, reflectedArg, thw.getClass(), thw.getMessage()));
                }
            final Throwable _thw = thw;
            Optional<Throwable> next = Optional.of(thw).map(Throwable::getCause).filter((<no type> t) -> (t != _thw));
            if ((! next.isPresent()))
                {
                  break;
                }
            thw = next.get();
          }
        throw BuildException.of(e);
      }
  }
};
  }
  private AttributeSetter getEnumSetter(final Class<?> reflectedArg, final Method m, final Class<?> arg) {
    if (reflectedArg.isEnum())
        {
          return new AttributeSetter(m, arg) {
  public @Override Enum<?> toTargetType(Project project, String value) {
    try
      {
        final @SuppressWarnings({"unchecked", "rawtypes"}) Enum<?> result = Enum.valueOf((Class<? extends Enum>) reflectedArg, value);
        return result;
      }
    catch (final IllegalArgumentException e)
      {
        throw new BuildException(((("'" + value) + "' is not a permitted value for ") + reflectedArg.getName()));
      }
  }
};
        }
    return null;
  }
  /**
     * @param   project
     * @param   element
     * @  return  <not empty>
   */
  private String getElementName(final Project project, final Object element) {
    return project.getElementName(element);
  }
  /**
     * @param   methodName
     * @param   prefix
     * @  return  <not empty>
   */
  private static String getPropertyName(final String methodName, final String prefix) {
    return methodName.substring(prefix.length()).toLowerCase(Locale.ENGLISH);
  }
  /**
   */
  public static void clearCache() {
    HELPERS.clear();
  }
  /**
     * @param   project
     * @param   parent
     * @param   elementName
     * @  return  <not empty>
     * @throws   BuildException
   */
  private NestedCreator createAddTypeCreator(final Project project, final Object parent, final String elementName) throws BuildException {
    if (addTypeMethods.isEmpty())
        {
          return null;
        }
    final ComponentHelper helper = ComponentHelper.getComponentHelper(project);
    final MethodAndObject restricted = createRestricted(helper, elementName, addTypeMethods);
    final MethodAndObject topLevel = createTopLevel(helper, elementName, addTypeMethods);
    if (((restricted == null) && (topLevel == null)))
        {
          return null;
        }
    if (((restricted != null) && (topLevel != null)))
        {
          throw new BuildException(("ambiguous: type and component definitions for " + elementName));
        }
    final MethodAndObject methodAndObject = ((restricted == null) ? topLevel : restricted);
    Object rObject = methodAndObject.object;
    if ((methodAndObject.object instanceof PreSetDef.PreSetDefinition))
        {
          rObject = ((PreSetDef.PreSetDefinition) methodAndObject.object).createObject(project);
        }
    final Object nestedObject = methodAndObject.object;
    final Object realObject = rObject;
    return new NestedCreator(methodAndObject.method) {
  @Override Object create(final Project project, final Object parent, final Object ignore) throws InvocationTargetException, IllegalAccessException {
    if ((! getMethod().getName().endsWith("Configured")))
        {
          getMethod().invoke(parent, realObject);
        }
    return nestedObject;
  }
  @Override Object getRealObject() {
    return realObject;
  }
  @Override void store(final Object parent, final Object child) throws InvocationTargetException, IllegalAccessException, InstantiationException {
    if (getMethod().getName().endsWith("Configured"))
        {
          getMethod().invoke(parent, realObject);
        }
  }
};
  }
  /**
     * @param   method
   */
  private void insertAddTypeMethod(final Method method) {
    final Class<?> argClass = method.getParameterTypes()[0];
    final int size = addTypeMethods.size();
    for (int c = 0;; (c < size); ++ c) 
      {
        final Method current = addTypeMethods.get(c);
        if (current.getParameterTypes()[0].equals(argClass))
            {
              if ("addConfigured".equals(method.getName()))
                  {
                    addTypeMethods.set(c, method);
                  }
              return;
            }
        if (current.getParameterTypes()[0].isAssignableFrom(argClass))
            {
              addTypeMethods.add(c, method);
              return;
            }
      }
    addTypeMethods.add(method);
  }
  /**
     * @param   paramClass
     * @param   methods
     * @  return  <not empty>
   */
  private Method findMatchingMethod(final Class<?> paramClass, final List<Method> methods) {
    if ((paramClass == null))
        {
          return null;
        }
    Class<?> matchedClass = null;
    Method matchedMethod = null;
    for (final Method method : methods) 
      {
        final Class<?> methodClass = method.getParameterTypes()[0];
        if (methodClass.isAssignableFrom(paramClass))
            {
              if ((matchedClass == null))
                  {
                    matchedClass = methodClass;
                    matchedMethod = method;
                  }
              else
                  if ((! methodClass.isAssignableFrom(matchedClass)))
                      {
                        throw new BuildException(((((("ambiguous: types " + matchedClass.getName()) + " and ") + methodClass.getName()) + " match ") + paramClass.getName()));
                      }
            }
      }
    return matchedMethod;
  }
  private String condenseText(final String text) {
    if ((text.length() <= MAX_REPORT_NESTED_TEXT))
        {
          return text;
        }
    final int ends = ((MAX_REPORT_NESTED_TEXT - ELLIPSIS.length()) / 2);
    return new StringBuffer(text).replace(ends, (text.length() - ends), ELLIPSIS).toString();
  }
  /**
   */
  private AntTypeDefinition findRestrictedDefinition(final ComponentHelper helper, final String componentName, final List<Method> methods) {
    AntTypeDefinition definition = null;
    Class<?> matchedDefinitionClass = null;
    final List<AntTypeDefinition> definitions = helper.getRestrictedDefinitions(componentName);
    if ((definitions == null))
        {
          return null;
        }
    synchronized (definitions)
      {
        for (final AntTypeDefinition d : definitions) 
          {
            final Class<?> exposedClass = d.getExposedClass(helper.getProject());
            if ((exposedClass == null))
                {
                  continue ;
                }
            final Method method = findMatchingMethod(exposedClass, methods);
            if ((method == null))
                {
                  continue ;
                }
            if ((matchedDefinitionClass != null))
                {
                  throw new BuildException(((((("ambiguous: restricted definitions for " + componentName) + " ") + matchedDefinitionClass) + " and ") + exposedClass));
                }
            matchedDefinitionClass = exposedClass;
            definition = d;
          }
      }
    return definition;
  }
  private MethodAndObject createRestricted(final ComponentHelper helper, final String elementName, final List<Method> addTypeMethods) {
    final Project project = helper.getProject();
    final AntTypeDefinition restrictedDefinition = findRestrictedDefinition(helper, elementName, addTypeMethods);
    if ((restrictedDefinition == null))
        {
          return null;
        }
    final Method addMethod = findMatchingMethod(restrictedDefinition.getExposedClass(project), addTypeMethods);
    if ((addMethod == null))
        {
          throw new BuildException(("Ant Internal Error - contract mismatch for " + elementName));
        }
    final Object addedObject = restrictedDefinition.create(project);
    if ((addedObject == null))
        {
          throw new BuildException(((("Failed to create object " + elementName) + " of type ") + restrictedDefinition.getTypeClass(project)));
        }
    return new MethodAndObject(addMethod, addedObject);
  }
  private MethodAndObject createTopLevel(final ComponentHelper helper, final String elementName, final List<Method> methods) {
    final Class<?> clazz = helper.getComponentClass(elementName);
    if ((clazz == null))
        {
          return null;
        }
    final Method addMethod = findMatchingMethod(clazz, addTypeMethods);
    if ((addMethod == null))
        {
          return null;
        }
    final Object addedObject = helper.createComponent(elementName);
    return new MethodAndObject(addMethod, addedObject);
  }
}

[iloveeclipse]

The field in question we are resolving at at org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(TypeDeclaration.java:1395) is private final NestedCreator nestedCreator;

at org.eclipse.jdt.internal.compiler.ast.Initializer.resolve(Initializer.java:149) we are in

static {
  final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
  final Class<?>[] wrappers = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class};
  for (int i = 0;; (i < primitives.length); i ++) 
    {
      PRIMITIVE_TYPE_MAP.put(primitives[i], wrappers[i]);
    }
}

with the MethodScope in the static init method

--- Method Scope ---
	locals:
	startIndex = 0
	isConstructorCall = false
	initializedField = null
	lastVisibleFieldID = 0
	referenceContext = /**
   * @see #getHelper(Project , Class )
 */
public final class IntrospectionHelper {

at org.eclipse.jdt.internal.compiler.ast.ASTNode.resolveStatements(ASTNode.java:699)we are looking at statement

final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};

which is the LocalDeclaration we finally arriving at org.eclipse.jdt.internal.compiler.ast.LocalDeclaration.resolve(LocalDeclaration.java:379).

[srikanth-sankaran]

There is something specific to your set up that seems to be needed to reproduce.

I tried two things.

1. Just grab the offending static initializer block into a test case such as

import java.util.HashMap;
import java.util.Map;

public class X {
	private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_MAP = new HashMap<>(8);
	static {
		  final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
		  final Class<?>[] wrappers = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class};
		  for (int i = 0; (i < primitives.length); i ++) 
		    {
		      PRIMITIVE_TYPE_MAP.put(primitives[i], wrappers[i]);
		    }
		}
}

This compiles fine.

2. Into a fresh workspace launched with Version: 2026-09 (4.41) Build id: I20260723-2300, imported all plugins from the active target platform. Added org.apache.ant_1.10.17.v20260410-1000.jar to the installation's plugin directory; Via Ctrl+3, Added all plug-ins to Java workspace scope. And tried the call hierarchy and references. I don't see the problem still. If I do Ctrl H and search for declarations of IntrospectionHelper it shows up - indicating that the plugin is very much in the search scope.

Furthermore, if I debug this setup using an outer instance of Eclipse and have a conditional breakpoint in org.eclipse.jdt.internal.compiler.ast.TypeDeclaration.resolve(CompilationUnitScope) with the condition CharOperation.substringMatch("IntrospectionHelper".toCharArray(), this.name) that breakpoint does not trigger at all. So the NPE path does not seem exercised.

I think we will have to descend deeper in the call stack - for instances do we even find index matches from IntrospectionHelper ? Checking ...