fix typo in _syncEvent; make it possible for a component to entirely change the class of its render…

sky/framework/fn.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.
 
 library fn;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:sky' as sky;
 import 'reflect.dart' as reflect;
@@ skipping 170 matching lines @@
     List<EventHandler> newHandlers = events._handlers;
     int newStartIndex = 0;
     int newEndIndex = newHandlers.length;
 
     List<EventHandler> oldHandlers = old.events._handlers;
     int oldStartIndex = 0;
     int oldEndIndex = oldHandlers.length;
 
     // Skip over leading handlers that match.
     while (newStartIndex < newEndIndex && oldStartIndex < oldEndIndex) {
-      EventHandler newHander = newHandlers[newStartIndex];
+      EventHandler newHandler = newHandlers[newStartIndex];
       EventHandler oldHandler = oldHandlers[oldStartIndex];
-      if (newHander.type != oldHandler.type
-          || newHander.listener != oldHandler.listener)
+      if (newHandler.type != oldHandler.type
+          || newHandler.listener != oldHandler.listener)
         break;
       ++newStartIndex;
       ++oldStartIndex;
     }
 
     // Skip over trailing handlers that match.
     while (newStartIndex < newEndIndex && oldStartIndex < oldEndIndex) {
-      EventHandler newHander = newHandlers[newEndIndex - 1];
+      EventHandler newHandler = newHandlers[newEndIndex - 1];
       EventHandler oldHandler = oldHandlers[oldEndIndex - 1];
-      if (newHander.type != oldHandler.type
-          || newHander.listener != oldHandler.listener)
+      if (newHandler.type != oldHandler.type
+          || newHandler.listener != oldHandler.listener)
         break;
       --newEndIndex;
       --oldEndIndex;
     }
 
     sky.Element root = _root as sky.Element;
 
     for (int i = oldStartIndex; i < oldEndIndex; ++i) {
       EventHandler oldHandler = oldHandlers[i];
       root.removeEventListener(oldHandler.type, oldHandler.listener);
     }
 
     for (int i = newStartIndex; i < newEndIndex; ++i) {
-      EventHandler newHander = newHandlers[i];
-      root.addEventListener(newHander.type, newHander.listener);
+      EventHandler newHandler = newHandlers[i];
+      root.addEventListener(newHandler.type, newHandler.listener);
     }
   }
 
   void _syncNode([Element old]) {
     if (old == null) {
       old = _emptyElement;
     }
 
     _syncEvents(old);
 
@@ skipping 366 matching lines @@
     _currentOrder = _order;
     _currentlyRendering = this;
     _rendered = render();
     _currentlyRendering = null;
     _currentOrder = lastOrder;
 
     _rendered.events.addAll(events);
 
     _dirty = false;
 
-    // TODO(rafaelw): This prevents components from returning different node
-    // types as their root node at different times. Consider relaxing.
-    assert(oldRendered == null ||
-           _rendered.runtimeType == oldRendered.runtimeType);
+    if (oldRendered != null && _rendered.runtimeType != oldRendered.runtimeType)
+      oldRendered = null;
 
     if (_rendered._sync(oldRendered, host, insertBefore)) {
       _rendered = oldRendered; // retain stateful component
     }
     _root = _rendered._root;
     assert(_rendered._root is sky.Node);
   }
 
   void _renderIfDirty() {
     assert(_rendered != null);
@@ skipping 32 matching lines @@
 
       _sync(null, _host, null);
       assert(_root is sky.Node);
 
       sw.stop();
       if (_shouldLogRenderDuration)
         print("Initial render: ${sw.elapsedMicroseconds} microseconds");
     });
   }
 }