code: function compileAllRemainingDeps(classname, deps) {
          var checked = {};
          var depNames = { };
          depNames[classname] = true;
          
          function search(classname) {
            if (checked[classname]) {
              return;
            }
            checked[classname] = true;
  
            var info = db.classInfo[classname];
            if (info && info.dependsOn) {
              for (var depName in info.dependsOn) {
                var dd = info.dependsOn[depName];
                if (dd.load || dd.require || dd.defer || dd.construct) {
                  if (!allDeps.contains(depName)) {
                    depNames[depName] = true; 
                  }
                  search(depName);
                }
              }
            }
          }
          
          search(classname);
          for (var depName in depNames) {
            deps.push(depName);
          }
        }
docs: /*
  We could say that when a class is `.require`d, then we treat any of it's `construct:true` dependencies as `require:true`
  The problem is given this example:
  qx.core.Init.defer()
  qx.event.Registration.addListener
  qx.event.Registration.getManager
  qx.event.Manager.construct
  new qx.util.DeferredCall
  
  new qx.util.DeferredCall is a runtime only dependency so is not available.
  
  So the theory is that deferred calls tend to be about initialisation, so prioritising constructor dependencies
  may be helpful
   /*
  Recursively finds all the dependencies for a class which have not already been added
  to the list of classes to load.
  
  @param classname {String}
  @param deps {String[]} array to modify