Make the popup menu work again.

sky/sdk/lib/widgets/widget.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 import 'dart:sky' as sky;
 
 import '../app/view.dart';
 import '../rendering/box.dart';
 import '../rendering/object.dart';
 
 export '../rendering/box.dart' show BoxConstraints, BoxDecoration, Border, BorderSide, EdgeDims;
 export '../rendering/flex.dart' show FlexDirection;
 export '../rendering/object.dart' show Point, Size, Rect, Color, Paint, Path;
 
 final bool _shouldLogRenderDuration = false;
 
 // All Effen nodes derive from Widget. All nodes have a _parent, a _key and
 // can be sync'd.
 abstract class Widget {
 
-  Widget({ String key }) {
-    _key = key != null ? key : runtimeType.toString();
+  Widget({ String key }) : _key = key {
     assert(this is AbstractWidgetRoot || this is App || _inRenderDirtyComponents); // you should not build the UI tree ahead of time, build it only during build()
   }
 
   String _key;
   String get key => _key;
 
   Widget _parent;
   Widget get parent => _parent;
 
   bool _mounted = false;
@@ skipping 41 matching lines @@
 
   RenderObject _root;
   RenderObject get root => _root;
 
   // Subclasses which implements Nodes that become stateful may return true
   // if the |old| node has become stateful and should be retained.
   // This is called immediately before _sync().
   // Component._retainStatefulNodeIfPossible() calls syncFields().
   bool _retainStatefulNodeIfPossible(Widget old) => false;
 
-  bool get interchangeable => false; // if true, then keys can be duplicated
-
   void _sync(Widget old, dynamic slot);
   // 'slot' is the identifier that the parent RenderObjectWrapper uses to know
   // where to put this descendant
 
   Widget findAncestor(Type targetType) {
     var ancestor = _parent;
     while (ancestor != null && !reflectClass(ancestor.runtimeType).isSubtypeOf(reflectClass(targetType)))
       ancestor = ancestor._parent;
     return ancestor;
   }
@@ skipping 48 matching lines @@
       oldNode = null;
     }
 
     assert(!node.mounted);
     node.setParent(this);
     node._sync(oldNode, slot);
     assert(node.root is RenderObject);
     return node;
   }
 
-  String toString() => '$runtimeType($key)';
+  String toString() {
+    if (key == null)
+      return '$runtimeType(unkeyed)';
+    return '$runtimeType("$key")';
+  }
 
 }
 
 
 // Descendants of TagNode provide a way to tag RenderObjectWrapper and
 // Component nodes with annotations, such as event listeners,
 // stylistic information, etc.
 abstract class TagNode extends Widget {
 
   TagNode(Widget content, { String key })
@@ skipping 328 matching lines @@
   void _sync(Widget old, dynamic slot) {
     // TODO(abarth): We should split RenderObjectWrapper into two pieces so that
     //               RenderViewObject doesn't need to inherit all this code it
     //               doesn't need.
     assert(parent != null || this is RenderViewWrapper);
     if (old == null) {
       _root = createNode();
       _ancestor = findAncestor(RenderObjectWrapper);
       if (_ancestor is RenderObjectWrapper)
         _ancestor.insert(this, slot);
-      else
-        print("$this has no ancestor");
     } else {
       _root = old.root;
       _ancestor = old._ancestor;
     }
     assert(_root == root); // in case a subclass reintroduces it
     assert(root != null);
     assert(mounted);
     _nodeMap[root] = this;
     syncRenderObject(old);
   }
@@ skipping 105 matching lines @@
       assert(child != null);
       removeChild(child);
     }
     super.remove();
   }
 
   bool _debugHasDuplicateIds() {
     var idSet = new HashSet<String>();
     for (var child in children) {
       assert(child != null);
-      if (child.interchangeable)
+      if (child.key == null)
         continue; // when these nodes are reordered, we just reassign the data
 
       if (!idSet.add(child.key)) {
-        throw '''If multiple non-interchangeable nodes exist as children of another node, they must have unique keys. Duplicate: "${child.key}"''';
+        throw '''If multiple keyed nodes exist as children of another node, they must have unique keys. $this has duplicate child key "${child.key}".''';
       }
     }
     return false;
   }
 
   void syncRenderObject(MultiChildRenderObjectWrapper old) {
     super.syncRenderObject(old);
 
     final root = this.root; // TODO(ianh): Remove this once the analyzer is cleverer
     if (root is! ContainerRenderObjectMixin)
@@ skipping 47 matching lines @@
       }
     }
 
     void ensureOldIdMap() {
       if (oldNodeIdMap != null)
         return;
 
       oldNodeIdMap = new HashMap<String, Widget>();
       for (int i = oldStartIndex; i < oldEndIndex; i++) {
         var node = oldChildren[i];
-        if (!node.interchangeable)
+        if (node.key != null)
           oldNodeIdMap.putIfAbsent(node.key, () => node);
       }
     }
 
     bool searchForOldNode() {
-      if (currentNode.interchangeable)
+      if (currentNode.key == null)
         return false; // never re-order these nodes
 
       ensureOldIdMap();
       oldNode = oldNodeIdMap[currentNode.key];
       if (oldNode == null)
         return false;
 
       oldNodeIdMap[currentNode.key] = null; // mark it reordered
       assert(root is ContainerRenderObjectMixin);
       assert(old.root is ContainerRenderObjectMixin);
@@ skipping 159 matching lines @@
     if (root.parent == null) {
       // we haven't attached it yet
       assert(_container.child == null);
       _container.child = root;
     }
     assert(root.parent == _container);
   }
 
   Widget build() => builder();
 }