I pulled up the notion of dynamically attachable fragment root files to VFSClassLoaderPolicy

   /**
    * Attach a new fragment root to the policy.
    * @param fragRoot The fragment root file
    */
   public void attachFragment(VirtualFile fragRoot)
   {
      if (fragRoot == null)
         throw new IllegalArgumentException("Null fragment file");
      
      if (fragments == null)
         fragments = new CopyOnWriteArrayList<VirtualFile>();
      
      fragments.add(fragRoot);
   }
   
   /**
    * Detach a fragment root from the policy.
    * @param fragRoot The fragment root file
    * @return true if the fragment could be detached
    */
   public boolean detachFragment(VirtualFile fragRoot)
   {
      if (fragRoot == null)
         throw new IllegalArgumentException("Null fragment file");
      
      if (fragments == null)
         return false;
      
      return fragments.remove(fragRoot);
   }
   
   /**
    * Get the array of attached fragment root files.
    * @return The array of attached fragment root files or null.
    */
   public VirtualFile[] getFragmentRoots()
   {
      if (fragments == null)
         return null;
      
      VirtualFile[] retarr = new VirtualFile[fragments.size()];
      fragments.toArray(retarr);
      return retarr;
   }

By default VFSClassLoaderPolicy has no fragments attached.

If the policy cannot find a resource in the set of its root files, it falls back to list of attached fragment root files

   /**
    * Find the virtual file information for a path
    * 
    * @param path the path
    * @return the virtual file information
    */
   protected VirtualFileInfo findVirtualFileInfo(String path)
   {
      VirtualFileInfo result = vfsCache.get(path);
      if (result != null)
         return result;
      
      for (VirtualFile root : roots)
      {
         try
         {
            VirtualFile file = root.getChild(path);
            if (file != null)
            {
               result = new VirtualFileInfo(file, root);
               vfsCache.put(path, result);
               return result;
            }
         }
         catch (Exception ignored)
         {
         }
      }
      
      if (fragments != null)
      {
         for (VirtualFile root : fragments)
         {
            try
            {
               VirtualFile file = root.getChild(path);
               if (file != null)
               {
                  result = new VirtualFileInfo(file, root);
                  vfsCache.put(path, result);
                  return result;
               }
            }
            catch (Exception ignored)
            {
            }
         }
      }
      
      return null;
   }

As a result, the hacks in OSGiBundleClassLoader.loadClass(String classname) and OSGiClassLoaderPolicy.getResource(String path) have been removed, which enables fragment support in jbossas where we have no control over the CL domain to create a custom OSGiBundleClassLoader.

Adrian, posted in https://community.jboss.org/thread/97003

4) Allow fragments - i.e. additions to the "classpath" of a classloader

...

I think (4) would be better implemented in the deployers by allowing one deployment
to dynamically become a subdeployment of another one. But this still requires
a mechanism to augment the classpath roots in the VFSClassLoaderPolicy.

The reason to pull fragment support up to the base layer was that

   protected VirtualFileInfo findVirtualFileInfo(String path)
   {
       ...
   }

cannot really be subclassed (despite its signature) because the return type VirtualFileInfo was private.

I promoted this type to top-level, which now allows me to do the fragment handling for class and resource lookups in OSGiClassLoaderPolicy.