vm/observatory: Clean up script access

runtime/vm/object.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 8287 matching lines @@
   result.SetLocationOffset(0, 0);
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
 
+RawLibrary* Script::FindLibrary() const {
+  Isolate* isolate = Isolate::Current();
+  const GrowableObjectArray& libs = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->libraries());
+  Library& lib = Library::Handle();
+  Array& scripts = Array::Handle();
+  for (intptr_t i = 0; i < libs.Length(); i++) {
+    lib ^= libs.At(i);
+    scripts = lib.LoadedScripts(false);
+    for (intptr_t j = 0; j < scripts.Length(); j++) {
+      if (scripts.At(j) == raw()) {
+        return lib.raw();
+      }
+    }
+  }
+  return Library::null();

[Michael Lippautz (Google), 2014/07/15 17:52:55]

This is not UNREACHABLE(), as we can still use scripts on their own, e.g. see
runtime/vm/report_test.cc

+}
+
+
 // See also Dart_ScriptGetTokenInfo.
 void Script::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
   const String& name = String::Handle(url());
   ASSERT(!name.IsNull());
   const String& encoded_url = String::Handle(String::EncodeURI(name));
   ASSERT(!encoded_url.IsNull());
-  jsobj.AddPropertyF("id", "scripts/%s", encoded_url.ToCString());
+  const Library& lib = Library::Handle(FindLibrary());
+  intptr_t lib_index = (lib.IsNull()) ? -1 : lib.index();
+  jsobj.AddPropertyF("id", "libraries/%" Pd "/scripts/%s",
+      lib_index, encoded_url.ToCString());
   jsobj.AddProperty("name", name.ToCString());
   jsobj.AddProperty("user_name", name.ToCString());
   jsobj.AddProperty("kind", GetKindAsCString());
   if (ref) {
     return;
   }
+  jsobj.AddProperty("owning_library", lib);
   const String& source = String::Handle(Source());
   jsobj.AddProperty("source", source.ToCString());
 
   // Print the line number table
   {
     JSONArray tokenPosTable(&jsobj, "tokenPosTable");
 
     const GrowableObjectArray& lineNumberArray =
         GrowableObjectArray::Handle(GenerateLineNumberArray());
     Object& value = Object::Handle();
@@ skipping 530 matching lines @@
     script_obj ^= scripts.At(i);
     if (script_obj.raw() == candidate.raw()) {
       // We already have a reference to this script.
       return;
     }
   }
   // Add script to the list of scripts.
   scripts.Add(candidate);
 }
 
-RawArray* Library::LoadedScripts() const {
+RawArray* Library::LoadedScripts(bool cached) const {

[Michael Lippautz (Google), 2014/07/15 17:52:55]

This whole function could be rewritten to use ClassDictionaryIterator() and
iterate over (anon) classes and their functions/fields. Opinions?

   // We compute the list of loaded scripts lazily. The result is
   // cached in loaded_scripts_.
-  if (loaded_scripts() == Array::null()) {
+  if (!cached || loaded_scripts() == Array::null()) {

[hausner, 2014/07/15 20:34:03]

I'm afraid this may have unintended side effects. Since LoadedScripts was
initially written, the VM now produces lots of tiny scripts as a side effect of
evaluating expressions. You probably find all these scripts and store them in
loaded_scripts_ each time LoadedScripts(false) is called. This means we hang on
to the script objects and they no longer get GCed. Also, when the debugger asks
for the list of loaded scripts, we send all these throw-away scripts that were
produced.

[Michael Lippautz (Google), 2014/07/15 21:20:55]

Thanks for the (offline) clarifications. The cache is not needed for this CL.
While libraries may be deferred, scripts imported in a library are loaded all at
once.

     // Iterate over the library dictionary and collect all scripts.
     const GrowableObjectArray& scripts =
         GrowableObjectArray::Handle(GrowableObjectArray::New(8));
     Object& entry = Object::Handle();
     Class& cls = Class::Handle();
     Class& patch_cls = Class::Handle();
     Script& owner_script = Script::Handle();
     Script& patch_script = Script::Handle();
     DictionaryIterator it(*this);
     while (it.HasNext()) {
       entry = it.GetNext();
       if (entry.IsClass()) {
         owner_script = Class::Cast(entry).script();
         patch_cls = Class::Cast(entry).patch_class();
         if (!patch_cls.IsNull()) {
           patch_script = patch_cls.script();
           AddScriptIfUnique(scripts, patch_script);
         }
       } else if (entry.IsFunction()) {
         owner_script = Function::Cast(entry).script();
       } else if (entry.IsField()) {
         cls = Field::Cast(entry).owner();
         owner_script = cls.script();
       } else {
         continue;
       }
       AddScriptIfUnique(scripts, owner_script);
     }
+    Array& anon_classes = Array::Handle(anonymous_classes());
+    Function& func = Function::Handle();
+    Array& functions = Array::Handle();
+    for (intptr_t i = 0; i < anon_classes.Length(); i++) {
+      cls ^= anon_classes.At(i);
+      if (cls.IsNull()) continue;
+      owner_script = cls.script();
+      AddScriptIfUnique(scripts, owner_script);
+      functions = cls.functions();
+      for (intptr_t j = 0; j < functions.Length(); j++) {
+        func ^= functions.At(j);
+        owner_script = func.script();
+        AddScriptIfUnique(scripts, owner_script);
+      }
+    }
 
     // Create the array of scripts and cache it in loaded_scripts_.
     const Array& scripts_array = Array::Handle(Array::MakeArray(scripts));
     StorePointer(&raw_ptr()->loaded_scripts_, scripts_array.raw());
   }
   return loaded_scripts();
 }
 
 
 // TODO(hausner): we might want to add a script dictionary to the
@@ skipping 10166 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart