Support Dart debugger API directly

tools/dom/src/native_DOMImplementation.dart

 // 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.
 
 part of html;
 
+class _Property {
+  _Property(this.name) :
+      _hasValue = false,
+      writable = false,
+      isMethod = false,
+      isOwn = true,
+      wasThrown = false;
+
+  bool get hasValue => _hasValue;
+  get value => _value;
+  set value(v) {
+    _value = v;
+    _hasValue = true;
+  }
+
+  final String name;
+  Function setter;
+  Function getter;
+  var _value;
+  bool _hasValue;
+  bool writable;
+  bool isMethod;
+  bool isOwn;
+  bool wasThrown;
+}
+
 class _ConsoleVariables {
   Map<String, Object> _data = new Map<String, Object>();
 
   /**
    * Forward member accesses to the backing JavaScript object.
    */
   noSuchMethod(Invocation invocation) {
     String member = MirrorSystem.getName(invocation.memberName);
     if (invocation.isGetter) {
       return _data[member];
     } else if (invocation.isSetter) {
       assert(member.endsWith('='));
       member = member.substring(0, member.length - 1);
       _data[member] = invocation.positionalArguments[0];
     } else {
       return Function.apply(_data[member], invocation.positionalArguments, invocation.namedArguments);
     }
   }
 
   void clear() => _data.clear();
 
   /**
    * List all variables currently defined.
    */
-  List variables() => _data.keys.toList(growable: false);
+  List variables() => _data.keys.toList();
+}
+
+/**
+ * Base class for invocation trampolines used to closurize methods, getters
+ * and setters.
+ */
+abstract class _Trampoline implements Function {
+  final ObjectMirror _receiver;
+  final MethodMirror _methodMirror;
+  final Symbol _selector;
+
+  _Trampoline(this._receiver, this._methodMirror, this._selector);
+}
+
+class _MethodTrampoline extends _Trampoline {
+  _MethodTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :
+      super(receiver, methodMirror, selector);
+
+  noSuchMethod(Invocation msg) {
+    if (msg.memberName != #call) return super.noSuchMethod(msg);
+    return _receiver.invoke(_selector,
+                            msg.positionalArguments,
+                            msg.namedArguments).reflectee;
+  }
+}
+
+/**
+ * Invocation trampoline class used to closurize getters.
+ */
+class _GetterTrampoline extends _Trampoline {
+  _GetterTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :
+      super(receiver, methodMirror, selector);
+
+  call() => _receiver.getField(_selector).reflectee;
+}
+
+/**
+ * Invocation trampoline class used to closurize setters.
+ */
+class _SetterTrampoline extends _Trampoline {
+  _SetterTrampoline(ObjectMirror receiver, MethodMirror methodMirror, Symbol selector) :
+      super(receiver, methodMirror, selector);
+
+  call(value) {
+    _receiver.setField(_selector, value);
+  }
 }
 
 class _Utils {
   static double dateTimeToDouble(DateTime dateTime) =>
       dateTime.millisecondsSinceEpoch.toDouble();
   static DateTime doubleToDateTime(double dateTime) {
     try {
       return new DateTime.fromMillisecondsSinceEpoch(dateTime.toInt());
     } catch(_) {
       // TODO(antonnm): treat exceptions properly in bindings and
@@ skipping 95 matching lines @@
     var map = {};
     for (int i = 0; i < localVariables.length; i+=2) {
       map[stripMemberName(localVariables[i])] = localVariables[i+1];
     }
     return map;
   }
 
   static _ConsoleVariables _consoleTempVariables = new _ConsoleVariables();
 
   /**
-   * Header passed in from the Dartium Developer Tools when an expression is
-   * evaluated in the console as opposed to the watch window or another context
-   * that does not expect REPL support.
-   */
-  static const _CONSOLE_API_SUPPORT_HEADER =
-      'with ((console && console._commandLineAPI) || { __proto__: null }) {\n';
-  static bool expectsConsoleApi(String expression) {
-    return expression.indexOf(_CONSOLE_API_SUPPORT_HEADER) == 0;;
-  }
-
-  /**
    * Takes an [expression] and a list of [local] variable and returns an
    * expression for a closure with a body matching the original expression
    * where locals are passed in as arguments. Returns a list containing the
    * String expression for the closure and the list of arguments that should
    * be passed to it. The expression should then be evaluated using
    * Dart_EvaluateExpr which will generate a closure that should be invoked
    * with the list of arguments passed to this method.
    *
    * For example:
    * <code>
    * _consoleTempVariables = {'a' : someValue, 'b': someOtherValue}
-   * wrapExpressionAsClosure("${_CONSOLE_API_SUPPORT_HEADER}foo + bar + a",
-   *                         ["bar", 40, "foo", 2])
+   * wrapExpressionAsClosure("foo + bar + a", ["bar", 40, "foo", 2], true)
    * </code>
    * will return:
    * <code>
    * ["""(final $consoleVariables, final bar, final foo, final a, final b) =>
    * (foo + bar + a
    * )""",
    * [_consoleTempVariables, 40, 2, someValue, someOtherValue]]
    * </code>
    */
-  static List wrapExpressionAsClosure(String expression, List locals) {
-    // FIXME: dartbug.com/10434 find a less fragile way to determine whether
-    // we need to strip off console API support added by InjectedScript.
+  static List wrapExpressionAsClosure(String expression, List locals,
+      bool includeCommandLineAPI) {
     var args = {};
     var sb = new StringBuffer("(");
     addArg(arg, value) {
       arg = stripMemberName(arg);
       if (args.containsKey(arg)) return;
       // We ignore arguments with the name 'this' rather than throwing an
       // exception because Dart_GetLocalVariables includes 'this' and it
       // is more convenient to filter it out here than from C++ code.
       // 'this' needs to be handled by calling Dart_EvaluateExpr with
       // 'this' as the target rather than by passing it as an argument.
       if (arg == 'this') return;
       if (args.isNotEmpty) {
         sb.write(", ");
       }
       sb.write("final $arg");
       args[arg] = value;
     }
 
-    if (expectsConsoleApi(expression)) {
-      expression = expression.substring(expression.indexOf('\n') + 1);
-      expression = expression.substring(0, expression.lastIndexOf('\n'));
-
+    if (includeCommandLineAPI) {
       addArg("\$consoleVariables", _consoleTempVariables);
 
       // FIXME: use a real Dart tokenizer. The following regular expressions
       // only allow setting variables at the immediate start of the expression
       // to limit the number of edge cases we have to handle.
 
       // Match expressions that start with "var x"
       final _VARIABLE_DECLARATION = new RegExp("^(\\s*)var\\s+(\\w+)");
       // Match expressions that start with "someExistingConsoleVar ="
       final _SET_VARIABLE = new RegExp("^(\\s*)(\\w+)(\\s*=)");
@@ skipping 36 matching lines @@
 
     // TODO(jacobr): remove the parentheses around the expresson once
     // dartbug.com/13723 is fixed. Currently we wrap expression in parentheses
     // to ensure only valid Dart expressions are allowed. Otherwise the DartVM
     // quietly ignores trailing Dart statements resulting in user confusion
     // when part of an invalid expression they entered is ignored.
     sb..write(') => (\n$expression\n)');
     return [sb.toString(), args.values.toList(growable: false)];
   }
 
-  /**
-   * TODO(jacobr): this is a big hack to get around the fact that we are still
-   * passing some JS expression to the evaluate method even when in a Dart
-   * context.
-   */
-  static bool isJsExpression(String expression) =>
-    expression.startsWith("(function getCompletions");
-
-  /**
-   * Returns a list of completions to use if the receiver is o.
-   */
-  static List<String> getCompletions(o) {
-    MirrorSystem system = currentMirrorSystem();
-    var completions = new Set<String>();
-    addAll(Map<Symbol, dynamic> map, bool isStatic) {
-      map.forEach((symbol, mirror) {
-        if (mirror.isStatic == isStatic && !mirror.isPrivate) {
+  static String _getShortSymbolName(Symbol symbol,
+                                    DeclarationMirror declaration) {
+    var name = MirrorSystem.getName(symbol);
+    if (declaration is MethodMirror) {
+      if (declaration.isSetter && name[name.length-1] == "=") {
+        return name.substring(0, name.length-1);
+      }
+      if (declaration.isConstructor) {
+        return name.substring(name.indexOf('.') + 1);
+      }
+    }
+    return name;
+  }
+
+  /**
+   * Adds all candidate String completitions from [declarations] to [output]
+   * filtering based on [staticContext] and [includePrivate].
+   */
+  static void _getCompletionsHelper(ClassMirror classMirror,
+      bool staticContext, LibraryMirror libraryMirror, Set<String> output) {
+    bool includePrivate = libraryMirror == classMirror.owner;
+    classMirror.declarations.forEach((symbol, declaration) {
+      if (!includePrivate && declaration.isPrivate) return;
+      if (declaration is VariableMirror) {
+        if (staticContext != declaration.isStatic) return;
+      } else if (declaration is MethodMirror) {
+        if (declaration.isOperator) return;
+        if (declaration.isConstructor) {
+          if (!staticContext) return;
+          var name = MirrorSystem.getName(declaration.constructorName);
+          if (name.isNotEmpty) output.add(name);
+          return;
+        }
+        if (staticContext != declaration.isStatic) return;
+      } else if (declaration is TypeMirror) {
+        return;
+      }
+      output.add(_getShortSymbolName(symbol, declaration));
+    });
+
+    if (!staticContext) {
+      for (var interface in classMirror.superinterfaces) {
+        _getCompletionsHelper(interface, staticContext,
+            libraryMirror, output);
+      }
+      if (classMirror.superclass != null) {
+        _getCompletionsHelper(classMirror.superclass, staticContext,
+            libraryMirror, output);
+      }
+    }
+  }
+
+  static void _getLibraryCompletionsHelper(
+      LibraryMirror library, bool includePrivate, Set<String> output) {
+    library.declarations.forEach((symbol, declaration) {
+      if (!includePrivate && declaration.isPrivate) return;
+      output.add(_getShortSymbolName(symbol, declaration));
+    });
+  }
+
+  static LibraryMirror getLibraryMirror(String url) =>
+      currentMirrorSystem().libraries[Uri.parse(url)];
+
+  /**
+   * Get code completions for [o] only showing privates from [libraryUrl].
+   */
+  static List<String> getObjectCompletions(o, String libraryUrl) {
+    var classMirror;
+    bool staticContext;
+    if (o is Type) {
+      classMirror = reflectClass(o);
+      staticContext = true;
+    } else {
+      classMirror = reflect(o).type;
+      staticContext = false;
+    }
+    var names = new Set<String>();
+    getClassCompletions(classMirror, names, staticContext, libraryUrl);
+    return names.toList()..sort();
+  }
+
+  static void getClassCompletions(ClassMirror classMirror, Set<String> names,
+      bool staticContext, String libraryUrl) {
+    LibraryMirror libraryMirror = getLibraryMirror(libraryUrl);
+    _getCompletionsHelper(classMirror, staticContext, libraryMirror, names);
+  }
+
+  static List<String> getLibraryCompletions(String url) {
+    var names = new Set<String>();
+    _getLibraryCompletionsHelper(getLibraryMirror(url), true, names);
+    return names.toList();
+  }
+
+  /**
+   * Get valid code completitions from within a library and all libraries
+   * imported by that library.
+   */
+  static List<String> getLibraryCompletionsIncludingImports(String url) {
+    var names = new Set<String>();
+    var libraryMirror = getLibraryMirror(url);
+    _getLibraryCompletionsHelper(libraryMirror, true, names);
+    for (var dependency in libraryMirror.libraryDependencies) {
+      if (dependency.isImport) {
+        if (dependency.prefix == null) {
+          _getLibraryCompletionsHelper(dependency.targetLibrary, false, names);
+        } else {
+          names.add(MirrorSystem.getName(dependency.prefix));
+        }
+      }
+    }
+    return names.toList();
+  }
+
+  static final SIDE_EFFECT_FREE_LIBRARIES = new Set<String>()
+      ..add('dart:html')
+      ..add('dart:indexed_db')
+      ..add('dart:svg')
+      ..add('dart:typed_data')
+      ..add('dart:web_audio')
+      ..add('dart:web_gl')
+      ..add('dart:web_sql');
+  /**
+   * For parity with the JavaScript debugger, we treat some getters as if
+   * they are fields so that users can see their values immediately.
+   * This matches JavaScript's behavior for getters on DOM objects.
+   * In the future we should consider adding an annotation to tag getters
+   * in user libraries as side effect free.
+   */
+  static bool _isSideEffectFreeGetter(MethodMirror methodMirror) {
+    var owner = methodMirror.owner;
+    var libraryMirror;
+    if (owner is ClassMirror) {
+      libraryMirror = owner.owner;
+    } else if (owner is LibraryMirror) {
+      libraryMirror = owner;
+    }
+    if (libraryMirror != null) {
+      // This matches JavaScript behavior. We should consider displaying
+      // getters for all dart platform libraries rather than just the DOM
+      // libraries.
+      if (libraryMirror.uri.scheme == 'dart' &&
+          SIDE_EFFECT_FREE_LIBRARIES.contains(libraryMirror.uri.toString())) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  /**
+   * Whether we should treat a property as a field for the purposes of the
+   * debugger.
+   */
+  static bool treatPropertyAsField(MethodMirror methodMirror) =>
+      (methodMirror.isGetter || methodMirror.isSetter) &&
+          (methodMirror.isSynthetic || _isSideEffectFreeGetter(methodMirror));
+
+  // TODO(jacobr): generate more concise function descriptions instead of
+  // dumping the entire function source.
+  static String describeFunction(function) {
+    if (function is _Trampoline) return function._methodMirror.source;
+    try {
+      return reflect(function).function.source;
+    } catch (e) {
+      return function.toString();
+    }
+  }
+
+  static List getInvocationTrampolineDetails(_Trampoline method) {
+    var loc = method._methodMirror.location;
+    return [loc.line, loc.column, loc.sourceUri.toString(),
+        MirrorSystem.getName(method._selector)];
+  }
+
+  static List getLibraryProperties(String libraryUrl, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var libraryMirror = getLibraryMirror(libraryUrl);
+    _addInstanceMirrors(libraryMirror, libraryMirror,
+        libraryMirror.declarations,
+        ownProperties, accessorPropertiesOnly, false, false,
+        properties);
+    if (!accessorPropertiesOnly) {
+      // We need to add class properties for all classes in the library.
+      libraryMirror.declarations.forEach((symbol, declarationMirror) {
+        if (declarationMirror is ClassMirror) {
           var name = MirrorSystem.getName(symbol);
-          if (mirror is MethodMirror && mirror.isSetter)
-            name = name.substring(0, name.length - 1);
-          completions.add(name);
+          if (declarationMirror.hasReflectedType
+              && !properties.containsKey(name)) {
+            properties[name] = new _Property(name)
+                ..value = declarationMirror.reflectedType;
+          }
         }
       });
     }
-
-    addForClass(ClassMirror mirror, bool isStatic) {
-      if (mirror == null)
+    return packageProperties(properties);
+  }
+
+  static List getObjectProperties(o, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var names = new Set<String>();
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    _addInstanceMirrors(objectMirror, classMirror.owner,
+        classMirror.instanceMembers,
+        ownProperties, accessorPropertiesOnly, false, true,
+        properties);
+    return packageProperties(properties);
+  }
+
+  static List getObjectClassProperties(o, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    _addInstanceMirrors(objectMirror, classMirror.owner,
+        classMirror.instanceMembers,
+        ownProperties, accessorPropertiesOnly, true, false,
+        properties);
+    _addStatics(classMirror, properties, accessorPropertiesOnly);
+    return packageProperties(properties);
+  }
+
+  static List getClassProperties(Type t, bool ownProperties,
+      bool accessorPropertiesOnly) {
+    var properties = new Map<String, _Property>();
+    var classMirror = reflectClass(t);
+    _addStatics(classMirror, properties, accessorPropertiesOnly);
+    return packageProperties(properties);
+  }
+
+  static void _addStatics(ClassMirror classMirror,
+                          Map<String, _Property> properties,
+                          bool accessorPropertiesOnly) {
+    classMirror.declarations.forEach((symbol, declaration) {
+      var name = _getShortSymbolName(symbol, declaration);
+      if (declaration is VariableMirror) {
+        if (accessorPropertiesOnly) return;
+        if (!declaration.isStatic) return;
+        properties.putIfAbsent(name, () => new _Property(name))
+            ..value = classMirror.getField(symbol).reflectee
+            ..writable = declaration.isFinal && !declaration.isConst;
+      } else if (declaration is MethodMirror) {
+        MethodMirror methodMirror = declaration;
+        // FIXMEDART: should we display constructors?
+        if (methodMirror.isConstructor) return;
+        if (!methodMirror.isStatic) return;
+        if (accessorPropertiesOnly) {
+          if (methodMirror.isRegularMethod ||
+              treatPropertyAsField(methodMirror)) {
+            return;
+          }
+        } else if (!methodMirror.isRegularMethod &&
+            !treatPropertyAsField(methodMirror)) {
+          return;
+        }
+        var property = properties.putIfAbsent(name, () => new _Property(name));
+        if (methodMirror.isRegularMethod) {
+          property
+              ..value = new _MethodTrampoline(classMirror, methodMirror, symbol)
+              ..isMethod = true;
+        } else if (methodMirror.isGetter) {
+          if (treatPropertyAsField(methodMirror)) {
+            try {
+              property.value = classMirror.getField(symbol).reflectee;
+            } catch (e) {
+              property
+                ..wasThrown = true
+                ..value = e;
+            }
+          } else if (accessorPropertiesOnly) {
+            property.getter = new _GetterTrampoline(classMirror,
+                methodMirror, symbol);
+          }
+        } else if (methodMirror.isSetter) {
+          if (accessorPropertiesOnly && !treatPropertyAsField(methodMirror)) {
+            property.setter = new _SetterTrampoline(classMirror,
+                methodMirror, classMirror.owner);
+          }
+          property.writable = true;
+        }
+      }
+    });
+  }
+
+  /**
+   * Helper method that handles collecting up properties from classes
+   * or libraries using the filters [ownProperties], [accessorPropertiesOnly],
+   * [hideFields], and [hideMethods] to determine which properties are
+   * collected. [accessorPropertiesOnly] specifies whether all properties
+   * should be returned or just accessors. [hideFields] specifies whether
+   * fields should be hidden. hideMethods specifies whether methods should be
+   * shown or hidden. [ownProperties] is not currently used but is part of the
+   * Blink devtools API for enumerating properties.
+   */
+  static void _addInstanceMirrors(
+      ObjectMirror objectMirror,
+      LibraryMirror libraryMirror,
+      Map<Symbol, Mirror> declarations,
+      bool ownProperties, bool accessorPropertiesOnly,
+      bool hideFields, bool hideMethods,
+      Map<String, _Property> properties) {
+    declarations.forEach((Symbol symbol, Mirror declaration) {
+      if (declaration is TypedefMirror || declaration is ClassMirror) return;
+      var name = _getShortSymbolName(symbol, declaration);
+      bool isField = declaration is VariableMirror ||
+          (declaration is MethodMirror && treatPropertyAsField(declaration));
+      if ((isField && hideFields) || (hideMethods && !isField)) return;
+      if (accessorPropertiesOnly) {
+        if (declaration is ClassMirror || declaration is VariableMirror ||
+            declaration.isRegularMethod || isField) {
+          return;
+        }
+      } else if (declaration is MethodMirror &&
+          (declaration.isGetter || declaration.isSetter) &&
+          !treatPropertyAsField(declaration)) {
         return;
-      addAll(mirror.declarations, isStatic);
-      if (mirror.superclass != null)
-        addForClass(mirror.superclass, isStatic);
-      for (var interface in mirror.superinterfaces) {
-        addForClass(interface, isStatic);
-      }
-    }
-
-    if (o is Type) {
-      addForClass(reflectClass(o), true);
-    } else {
-      addForClass(reflect(o).type, false);
-    }
-    return completions.toList(growable: false);
-  }
-
-  /**
-   * Convenience helper to get the keys of a [Map] as a [List].
-   */
+      }
+      var property = properties.putIfAbsent(name, () => new _Property(name));
+      if (declaration is VariableMirror) {
+        property.value = objectMirror.getField(symbol).reflectee;
+        property.writable = !declaration.isFinal && !declaration.isConst;
+      } else if (declaration is ClassMirror) {
+        property.value = declaration.runtimeType;
+      } else if (declaration.isRegularMethod) {
+        property.value = new _MethodTrampoline(objectMirror,
+            declaration, symbol);
+        property.isMethod = true;
+      } else if (declaration.isGetter) {
+        if (treatPropertyAsField(declaration)) {
+          try {
+            property.value = objectMirror.getField(symbol).reflectee;
+          } catch (e) {
+            property
+                ..wasThrown = true
+                ..value = e;
+          }
+        } else if (accessorPropertiesOnly) {
+          property.getter = new _GetterTrampoline(objectMirror,
+              declaration, symbol);
+        }
+      } else if (declaration.isSetter) {
+        property.writable = true;
+        if (accessorPropertiesOnly && !treatPropertyAsField(declaration)) {
+          property.setter = new _SetterTrampoline(objectMirror,
+              declaration, MirrorSystem.getSymbol(name, libraryMirror));
+        }
+      }
+    });
+  }
+
+  /**
+   * Flatten down the properties data structure into a List that is easy to
+   * access from native code.
+   */
+  static List packageProperties(Map<String, _Property> properties) {
+    var ret = [];
+    for (var property in properties.values) {
+      ret.addAll([property.name,
+                  property.setter,
+                  property.getter,
+                  property.value,
+                  property.hasValue,
+                  property.writable,
+                  property.isMethod,
+                  property.isOwn,
+                  property.wasThrown]);
+    }
+    return ret;
+  }
+  
+  /**
+   * Get a property, returning null if the property does not exist.
+   * For private property names, we attempt to resolve the property in the
+   * context of each library that the property name could be associated with.
+   */
+  static getObjectPropertySafe(o, String propertyName) {
+    var objectMirror = reflect(o);
+    var classMirror = objectMirror.type;
+    if (propertyName.startsWith("_")) {
+      var attemptedLibraries = new Set<LibraryMirror>(); 
+      while (classMirror != null) {
+        LibraryMirror library = classMirror.owner;
+        if (!attemptedLibraries.contains(library)) {
+          try {
+            return objectMirror.getField(
+                MirrorSystem.getSymbol(propertyName, library)).reflectee;
+          } catch (e) { }
+          attemptedLibraries.add(library);
+        }
+        classMirror = classMirror.superclass;
+      }
+      return null;     
+    }
+    try {
+      return objectMirror.getField(
+          MirrorSystem.getSymbol(propertyName)).reflectee;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * Helper to wrap the inspect method on InjectedScriptHost to provide the
+   * inspect method required for the 
+   */
+  static List consoleApi(host) {
+    return [
+        "inspect",
+        (o) {
+          host.inspect(o, null);
+          return o;
+        },
+        "dir",
+        window().console.dir,
+        "dirxml",
+        window().console.dirxml
+        // FIXME: add copy method.
+        ];
+  }
+
   static List getMapKeyList(Map map) => map.keys.toList();
 
  /**
    * Returns the keys of an arbitrary Dart Map encoded as unique Strings.
    * Keys that are strings are left unchanged except that the prefix ":" is
    * added to disambiguate keys from other Dart members.
    * Keys that are not strings have # followed by the index of the key in the map
    * prepended to disambuguate. This scheme is simplistic but easy to encode and
    * decode. The use case for this method is displaying all map keys in a human
    * readable way in debugging tools.
@@ skipping 278 matching lines @@
   _scheduleImmediateHelper._schedule(callback);
 };
 
 get _pureIsolateScheduleImmediateClosure => ((void callback()) =>
   throw new UnimplementedError("scheduleMicrotask in background isolates "
                                "are not supported in the browser"));
 
 void _initializeCustomElement(Element e) {
   _Utils.initializeCustomElement(e);
 }