Dependencies unloading classes loaded from load_once_paths?

I can't entirely tell if this is intended behavior or not. However,
here goes:

It appears that load_file in dependencies.rb does not check whether the
newly_defined_paths contains constants that cannot be unloaded. It
assumes that everything is unloadable and concatenates the results to
autoloaded_constants. The autoloaded_constants are then unloaded
(during development) after reloading a page.

This issue crops up in a scenario like the following:

a.rb:
class A
B # just causes missing_constant to load the file for B
end

b.rb:
class B
end

The situation here is that b.rb is contained in a path that has been
added to Dependencies.load_once_paths, while a.rb has not. As a
result, when load_file is called for a.rb, the newly defined paths will
be [A, B].

I have found that adding the following code BEFORE adding anything to
the autoloaded_constants ensures that unloadable constants are not
unloaded:

    ...
    result = nil
    newly_defined_paths = new_constants_in(*parent_paths) do
      result = load_without_new_constant_marking path
    end

    # New code starts here...
    newly_defined_paths.reject! do |new_path|
      if file_path = search_for_file(new_path.underscore)
        !loadable_constants_for_path(file_path).include?(new_path)
      else
        false
      end
    end
    # And ends here...

    autoloaded_constants.concat newly_defined_paths
    autoloaded_constants.uniq!
    log "loading #{path} defined #{newly_defined_paths * ', '}" unless
newly_defined_paths.empty?
    return result

This now prevents b.rb from ever being added to autoloaded_constants.
I hope that description made sense.

I was wondering if someone from core or with knowledge of the
Dependencies system could verify this as an issue or as expected
behavior... Thanks!