changeset 1625:d99fa86747ee

8147558: Add support for ES6 collections Reviewed-by: attila, mhaupt
author hannesw
date Mon, 15 Feb 2016 17:02:32 +0100
parents cfb316745693
children 221378857767
files buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/ClassGenerator.java buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/MemberInfo.java buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/StringConstants.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/AbstractIterator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/ArrayIterator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/IteratorResult.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/LinkedMap.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/MapIterator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeArray.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeMap.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeSet.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeString.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeSymbol.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeWeakMap.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeWeakSet.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/SetIterator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/StringIterator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/annotations/Attribute.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/AccessorProperty.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/FindProperty.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Property.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/PropertyMap.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptFunction.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptObject.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/SetMethodCreator.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/UserAccessorProperty.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/linker/PrimitiveLookup.java src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/resources/Messages.properties test/script/basic/es6.js test/script/basic/es6/iterator.js test/script/basic/es6/map.js test/script/basic/es6/set.js test/script/basic/es6/weakmap.js test/script/basic/es6/weakset.js
diffstat 35 files changed, 2876 insertions(+), 61 deletions(-) [+]
line wrap: on
line diff
--- a/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/ClassGenerator.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/ClassGenerator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -48,6 +48,7 @@
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.GET_CLASS_NAME_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.INIT;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.LIST_DESC;
+import static jdk.nashorn.internal.tools.nasgen.StringConstants.NATIVESYMBOL_TYPE;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.OBJECT_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.PROPERTYMAP_FIELD_NAME;
@@ -63,6 +64,8 @@
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_SETDOCUMENTATIONKEY_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTFUNCTION_TYPE;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SETTER_PREFIX;
+import static jdk.nashorn.internal.tools.nasgen.StringConstants.SYMBOL_DESC;
+import static jdk.nashorn.internal.tools.nasgen.StringConstants.SYMBOL_PREFIX;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.TYPE_OBJECT;
 
 import java.io.BufferedInputStream;
@@ -277,7 +280,7 @@
     static void newFunction(final MethodGenerator mi, final String objName, final String className, final MemberInfo memInfo, final List<MemberInfo> specs) {
         final boolean arityFound = (memInfo.getArity() != MemberInfo.DEFAULT_ARITY);
 
-        mi.loadLiteral(memInfo.getName());
+        loadFunctionName(mi, memInfo.getName());
         mi.visitLdcInsn(new Handle(H_INVOKESTATIC, className, memInfo.getJavaName(), memInfo.getJavaDesc()));
 
         assert specs != null;
@@ -305,8 +308,8 @@
         // dup of Collection instance
         mi.dup();
 
-        // property = AccessorProperty.create(key, flags, getter, setter);
-        mi.loadLiteral(propertyName);
+        // Load property name, converting to Symbol if it begins with "@@"
+        loadPropertyKey(mi, propertyName);
         // setup flags
         mi.push(memInfo.getAttributes());
         // setup getter method handle
@@ -319,6 +322,7 @@
             javaName = SETTER_PREFIX + memInfo.getJavaName();
             mi.visitLdcInsn(new Handle(H_INVOKEVIRTUAL, className, javaName, setterDesc(memInfo)));
         }
+        // property = AccessorProperty.create(key, flags, getter, setter);
         mi.invokeStatic(ACCESSORPROPERTY_TYPE, ACCESSORPROPERTY_CREATE, ACCESSORPROPERTY_CREATE_DESC);
         // boolean Collection.add(property)
         mi.invokeInterface(COLLECTION_TYPE, COLLECTION_ADD, COLLECTION_ADD_DESC);
@@ -333,8 +337,8 @@
         // dup of Collection instance
         mi.dup();
 
-        // property = AccessorProperty.create(key, flags, getter, setter);
-        mi.loadLiteral(propertyName);
+        // Load property name, converting to Symbol if it begins with "@@"
+        loadPropertyKey(mi, propertyName);
         // setup flags
         mi.push(getter.getAttributes());
         // setup getter method handle
@@ -347,6 +351,7 @@
             mi.visitLdcInsn(new Handle(H_INVOKESTATIC, className,
                     setter.getJavaName(), setter.getJavaDesc()));
         }
+        // property = AccessorProperty.create(key, flags, getter, setter);
         mi.invokeStatic(ACCESSORPROPERTY_TYPE, ACCESSORPROPERTY_CREATE, ACCESSORPROPERTY_CREATE_DESC);
         // boolean Collection.add(property)
         mi.invokeInterface(COLLECTION_TYPE, COLLECTION_ADD, COLLECTION_ADD_DESC);
@@ -365,6 +370,22 @@
         return getScriptClassInfo(new ClassReader(classBuf));
     }
 
+    private static void loadFunctionName(final MethodGenerator mi, final String propertyName) {
+        if (propertyName.startsWith(SYMBOL_PREFIX)) {
+            mi.loadLiteral("Symbol[" + propertyName.substring(2) + "]");
+        } else {
+            mi.loadLiteral(propertyName);
+        }
+    }
+
+    private static void loadPropertyKey(final MethodGenerator mi, final String propertyName) {
+        if (propertyName.startsWith(SYMBOL_PREFIX)) {
+            mi.getStatic(NATIVESYMBOL_TYPE, propertyName.substring(2), SYMBOL_DESC);
+        } else {
+            mi.loadLiteral(propertyName);
+        }
+    }
+
     private static ScriptClassInfo getScriptClassInfo(final ClassReader reader) {
         final ScriptClassInfoCollector scic = new ScriptClassInfoCollector();
         reader.accept(scic, 0);
--- a/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/MemberInfo.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/MemberInfo.java	Mon Feb 15 17:02:32 2016 +0100
@@ -28,6 +28,8 @@
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.OBJECT_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.SCRIPTOBJECT_DESC;
 import static jdk.nashorn.internal.tools.nasgen.StringConstants.STRING_DESC;
+import static jdk.nashorn.internal.tools.nasgen.StringConstants.TYPE_SYMBOL;
+
 import jdk.internal.org.objectweb.asm.Opcodes;
 import jdk.internal.org.objectweb.asm.Type;
 import jdk.nashorn.internal.objects.annotations.Where;
@@ -466,11 +468,10 @@
         switch (type.getSort()) {
             case Type.BOOLEAN:
             case Type.INT:
-            case Type.LONG:
             case Type.DOUBLE:
                 return true;
             default:
-                return false;
+                return type != TYPE_SYMBOL;
         }
     }
 
--- a/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/StringConstants.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/StringConstants.java	Mon Feb 15 17:02:32 2016 +0100
@@ -31,12 +31,14 @@
 import java.util.Collections;
 import java.util.List;
 import jdk.internal.org.objectweb.asm.Type;
+import jdk.nashorn.internal.objects.NativeSymbol;
 import jdk.nashorn.internal.runtime.AccessorProperty;
 import jdk.nashorn.internal.runtime.PropertyMap;
 import jdk.nashorn.internal.runtime.PrototypeObject;
 import jdk.nashorn.internal.runtime.ScriptFunction;
 import jdk.nashorn.internal.runtime.ScriptObject;
 import jdk.nashorn.internal.runtime.Specialization;
+import jdk.nashorn.internal.runtime.Symbol;
 
 /**
  * String constants used for code generation/instrumentation.
@@ -88,6 +90,8 @@
     static final Type TYPE_PROTOTYPEOBJECT    = Type.getType(PrototypeObject.class);
     static final Type TYPE_SCRIPTFUNCTION     = Type.getType(ScriptFunction.class);
     static final Type TYPE_SCRIPTOBJECT       = Type.getType(ScriptObject.class);
+    static final Type TYPE_NATIVESYMBOL       = Type.getType(NativeSymbol.class);
+    static final Type TYPE_SYMBOL             = Type.getType(Symbol.class);
 
     static final String PROTOTYPE_SUFFIX = "$Prototype";
     static final String CONSTRUCTOR_SUFFIX = "$Constructor";
@@ -101,7 +105,7 @@
     static final String ACCESSORPROPERTY_TYPE = TYPE_ACCESSORPROPERTY.getInternalName();
     static final String ACCESSORPROPERTY_CREATE = "create";
     static final String ACCESSORPROPERTY_CREATE_DESC =
-        Type.getMethodDescriptor(TYPE_ACCESSORPROPERTY, TYPE_STRING, Type.INT_TYPE, TYPE_METHODHANDLE, TYPE_METHODHANDLE);
+        Type.getMethodDescriptor(TYPE_ACCESSORPROPERTY, TYPE_OBJECT, Type.INT_TYPE, TYPE_METHODHANDLE, TYPE_METHODHANDLE);
 
     // PropertyMap
     static final String PROPERTYMAP_TYPE = TYPE_PROPERTYMAP.getInternalName();
@@ -143,4 +147,9 @@
     // ScriptObject.getClassName() method.
     static final String GET_CLASS_NAME = "getClassName";
     static final String GET_CLASS_NAME_DESC = Type.getMethodDescriptor(TYPE_STRING);
+
+    // NativeSymbol
+    static final String NATIVESYMBOL_TYPE = TYPE_NATIVESYMBOL.getInternalName();
+    static final String SYMBOL_DESC = TYPE_SYMBOL.getDescriptor();
+    static final String SYMBOL_PREFIX = "@@";
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/AbstractIterator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import java.lang.invoke.MethodHandle;
+import java.util.function.Consumer;
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.JSType;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.linker.Bootstrap;
+import jdk.nashorn.internal.runtime.linker.InvokeByName;
+import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * ECMA6 25.1.2 The %IteratorPrototype% Object
+ */
+@ScriptClass("Iterator")
+public abstract class AbstractIterator extends ScriptObject {
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private final static Object ITERATOR_INVOKER_KEY = new Object();
+    private final static Object NEXT_INVOKER_KEY     = new Object();
+    private final static Object DONE_INVOKER_KEY     = new Object();
+    private final static Object VALUE_INVOKER_KEY    = new Object();
+
+    /** ECMA6 iteration kinds */
+    enum IterationKind {
+        /** key iteration */
+        KEY,
+        /** value iteration */
+        VALUE,
+        /** key+value iteration */
+        KEY_VALUE
+    }
+
+    /**
+     * Create an abstract iterator object with the given prototype and property map.
+     *
+     * @param prototype the prototype
+     * @param map the property map
+     */
+    protected AbstractIterator(final ScriptObject prototype, final PropertyMap map) {
+        super(prototype, map);
+    }
+
+    /**
+     * 25.1.2.1 %IteratorPrototype% [ @@iterator ] ( )
+     *
+     * @param self the self object
+     * @return this iterator
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, name = "@@iterator")
+    public static Object getIterator(final Object self) {
+        return self;
+    }
+
+    @Override
+    public String getClassName() {
+        return "Iterator";
+    }
+
+    /**
+     * ES6 25.1.1.2 The Iterator Interface
+     *
+     * @param arg argument
+     * @return next iterator result
+     */
+    protected abstract IteratorResult next(final Object arg);
+
+    /**
+     * ES6 25.1.1.3 The IteratorResult Interface
+     *
+     * @param value result value
+     * @param done result status
+     * @param global the global object
+     * @return result object
+     */
+    protected IteratorResult makeResult(final Object value, final Boolean done, final Global global) {
+        return new IteratorResult(value, done, global);
+    }
+
+    /**
+     * ES6 7.4.1 GetIterator abstract operation
+     *
+     * @param iterable an object
+     * @param global the global object
+     * @return the iterator
+     */
+    public static Object getIterator(final Object iterable, final Global global) {
+        final Object object = Global.toObject(iterable);
+
+        if (object instanceof ScriptObject) {
+            // TODO we need to implement fast property access for Symbol keys in order to use InvokeByName here.
+            final Object getter = ((ScriptObject) object).get(NativeSymbol.iterator);
+
+            if (Bootstrap.isCallable(getter)) {
+                try {
+                    final MethodHandle invoker = global.getDynamicInvoker(ITERATOR_INVOKER_KEY,
+                            () -> Bootstrap.createDynamicCallInvoker(Object.class, Object.class, Object.class));
+
+                    final Object value = invoker.invokeExact(getter, iterable);
+                    if (JSType.isPrimitive(value)) {
+                        throw typeError("not.an.object", ScriptRuntime.safeToString(value));
+                    }
+                    return value;
+
+                } catch (final Throwable t) {
+                    throw new RuntimeException(t);
+                }
+            }
+            throw typeError("not.a.function", ScriptRuntime.safeToString(getter));
+        }
+
+        throw typeError("cannot.get.iterator", ScriptRuntime.safeToString(iterable));
+    }
+
+    /**
+     * Iterate over an iterable object, passing every value to {@code consumer}.
+     *
+     * @param iterable an iterable object
+     * @param global the current global
+     * @param consumer the value consumer
+     */
+    public static void iterate(final Object iterable, final Global global, final Consumer<Object> consumer) {
+
+        final Object iterator = AbstractIterator.getIterator(Global.toObject(iterable), global);
+
+        final InvokeByName nextInvoker = global.getInvokeByName(AbstractIterator.NEXT_INVOKER_KEY,
+                () -> new InvokeByName("next", Object.class, Object.class, Object.class));
+        final MethodHandle doneInvoker = global.getDynamicInvoker(AbstractIterator.DONE_INVOKER_KEY,
+                () -> Bootstrap.createDynamicInvoker("done", NashornCallSiteDescriptor.GET_PROPERTY, Object.class, Object.class));
+        final MethodHandle valueInvoker = global.getDynamicInvoker(AbstractIterator.VALUE_INVOKER_KEY,
+                () -> Bootstrap.createDynamicInvoker("value", NashornCallSiteDescriptor.GET_PROPERTY, Object.class, Object.class));
+
+        try {
+            do {
+                final Object next = nextInvoker.getGetter().invokeExact(iterator);
+                if (!Bootstrap.isCallable(next)) {
+                    break;
+                }
+
+                final Object result = nextInvoker.getInvoker().invokeExact(next, iterator, (Object) null);
+                if (!(result instanceof ScriptObject)) {
+                    break;
+                }
+
+                final Object done = doneInvoker.invokeExact(result);
+                if (JSType.toBoolean(done)) {
+                    break;
+                }
+
+                consumer.accept(valueInvoker.invokeExact(result));
+
+            } while (true);
+
+        } catch (final RuntimeException r) {
+            throw r;
+        } catch (final Throwable t) {
+            throw new RuntimeException(t);
+        }
+
+    }
+}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/ArrayIterator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.JSType;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+@ScriptClass("ArrayIterator")
+public class ArrayIterator extends AbstractIterator {
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private ScriptObject iteratedObject;
+    private long nextIndex = 0L;
+    private final IterationKind iterationKind;
+    private final Global global;
+
+
+    ArrayIterator(final Object iteratedObject, final IterationKind iterationKind, final Global global) {
+        super(global.getArrayIteratorPrototype(), $nasgenmap$);
+        this.iteratedObject = iteratedObject instanceof ScriptObject ? (ScriptObject) iteratedObject : null;
+        this.iterationKind = iterationKind;
+        this.global = global;
+    }
+
+    /**
+     * 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+     *
+     * @param self the self reference
+     * @param arg the argument
+     * @return the next result
+     */
+    @Function
+    public static Object next(final Object self, final Object arg) {
+        if (!(self instanceof ArrayIterator)) {
+            throw typeError("not.a.array.iterator", ScriptRuntime.safeToString(self));
+        }
+        return ((ArrayIterator)self).next(arg);
+    }
+
+    @Override
+    public String getClassName() {
+        return "Array Iterator";
+    }
+
+    @Override
+    protected IteratorResult next(final Object arg) {
+        final long index = nextIndex;
+
+        if (iteratedObject == null || index >= JSType.toUint32(iteratedObject.getLength())) {
+            // ES6 22.1.5.2.1 step 10
+            iteratedObject = null;
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        nextIndex++;
+
+        if (iterationKind == IterationKind.KEY_VALUE) {
+            final NativeArray value = new NativeArray(
+                    new Object[] {JSType.toNarrowestNumber(index), iteratedObject.get((double) index)});
+            return makeResult(value, Boolean.FALSE, global);
+        }
+
+        final Object value = iterationKind == IterationKind.KEY ?
+                JSType.toNarrowestNumber(index) : iteratedObject.get((double) index);
+        return makeResult(value, Boolean.FALSE, global);
+    }
+
+}
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java	Mon Feb 15 17:02:32 2016 +0100
@@ -95,6 +95,8 @@
     // (__FILE__, __DIR__, __LINE__)
     private static final Object LAZY_SENTINEL = new Object();
 
+    private static final String PACKAGE_PREFIX = "jdk.nashorn.internal.objects.";
+
     private InvokeByName TO_STRING;
     private InvokeByName VALUE_OF;
 
@@ -222,9 +224,6 @@
     @Property(name = "Number", attributes = Attribute.NOT_ENUMERABLE)
     public volatile Object number;
 
-    /** ECMA 2016 19.4.1 - Symbol constructor */
-    @Property(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
-    public volatile Object symbol;
 
     /**
      * Getter for ECMA 15.1.4.7 Date property
@@ -748,6 +747,147 @@
 
     private volatile Object float64Array;
 
+
+    /**
+     * Getter for the Symbol property.
+     *
+     * @param self self reference
+     * @return  the value of the Symbol property
+     */
+    @Getter(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
+    public static Object getSymbol(final Object self) {
+        final Global global = Global.instanceFrom(self);
+        if (global.symbol == LAZY_SENTINEL) {
+            global.symbol = global.getBuiltinSymbol();
+        }
+        return global.symbol;
+    }
+
+    /**
+     * Setter for the Symbol property.
+     *
+     * @param self self reference
+     * @param value value of the Symbol property
+     */
+    @Setter(name = "Symbol", attributes = Attribute.NOT_ENUMERABLE)
+    public static void setSymbol(final Object self, final Object value) {
+        Global.instanceFrom(self).symbol = value;
+    }
+
+    private volatile Object symbol;
+
+    /**
+     * Getter for the Map property.
+     *
+     * @param self self reference
+     * @return  the value of the Map property
+     */
+    @Getter(name = "Map", attributes = Attribute.NOT_ENUMERABLE)
+    public static Object getMap(final Object self) {
+        final Global global = Global.instanceFrom(self);
+        if (global.map == LAZY_SENTINEL) {
+            global.map = global.getBuiltinMap();
+        }
+        return global.map;
+    }
+
+    /**
+     * Setter for the Map property.
+     *
+     * @param self self reference
+     * @param value value of the Map property
+     */
+    @Setter(name = "Map", attributes = Attribute.NOT_ENUMERABLE)
+    public static void setMap(final Object self, final Object value) {
+        Global.instanceFrom(self).map = value;
+    }
+
+    private volatile Object map;
+
+    /**
+     * Getter for the WeakMap property.
+     *
+     * @param self self reference
+     * @return  the value of the WeakMap property
+     */
+    @Getter(name = "WeakMap", attributes = Attribute.NOT_ENUMERABLE)
+    public static Object getWeakMap(final Object self) {
+        final Global global = Global.instanceFrom(self);
+        if (global.weakMap == LAZY_SENTINEL) {
+            global.weakMap = global.getBuiltinWeakMap();
+        }
+        return global.weakMap;
+    }
+
+    /**
+     * Setter for the WeakMap property.
+     *
+     * @param self self reference
+     * @param value value of the WeakMap property
+     */
+    @Setter(name = "WeakMap", attributes = Attribute.NOT_ENUMERABLE)
+    public static void setWeakMap(final Object self, final Object value) {
+        Global.instanceFrom(self).weakMap = value;
+    }
+
+    private volatile Object weakMap;
+
+    /**
+     * Getter for the Set property.
+     *
+     * @param self self reference
+     * @return  the value of the Set property
+     */
+    @Getter(name = "Set", attributes = Attribute.NOT_ENUMERABLE)
+    public static Object getSet(final Object self) {
+        final Global global = Global.instanceFrom(self);
+        if (global.set == LAZY_SENTINEL) {
+            global.set = global.getBuiltinSet();
+        }
+        return global.set;
+    }
+
+    /**
+     * Setter for the Set property.
+     *
+     * @param self self reference
+     * @param value value of the Set property
+     */
+    @Setter(name = "Set", attributes = Attribute.NOT_ENUMERABLE)
+    public static void setSet(final Object self, final Object value) {
+        Global.instanceFrom(self).set = value;
+    }
+
+    private volatile Object set;
+
+    /**
+     * Getter for the WeakSet property.
+     *
+     * @param self self reference
+     * @return  the value of the WeakSet property
+     */
+    @Getter(name = "WeakSet", attributes = Attribute.NOT_ENUMERABLE)
+    public static Object getWeakSet(final Object self) {
+        final Global global = Global.instanceFrom(self);
+        if (global.weakSet == LAZY_SENTINEL) {
+            global.weakSet = global.getBuiltinWeakSet();
+        }
+        return global.weakSet;
+    }
+
+    /**
+     * Setter for the WeakSet property.
+     *
+     * @param self self reference
+     * @param value value of the WeakSet property
+     */
+    @Setter(name = "WeakSet", attributes = Attribute.NOT_ENUMERABLE)
+    public static void setWeakSet(final Object self, final Object value) {
+        Global.instanceFrom(self).weakSet = value;
+    }
+
+    private volatile Object weakSet;
+
     /** Nashorn extension: Java access - global.Packages */
     @Property(name = "Packages", attributes = Attribute.NOT_ENUMERABLE)
     public volatile Object packages;
@@ -907,6 +1047,15 @@
     private ScriptFunction builtinFloat32Array;
     private ScriptFunction builtinFloat64Array;
     private ScriptFunction builtinSymbol;
+    private ScriptFunction builtinMap;
+    private ScriptFunction builtinWeakMap;
+    private ScriptFunction builtinSet;
+    private ScriptFunction builtinWeakSet;
+    private ScriptObject   builtinIteratorPrototype;
+    private ScriptObject   builtinMapIteratorPrototype;
+    private ScriptObject   builtinSetIteratorPrototype;
+    private ScriptObject   builtinArrayIteratorPrototype;
+    private ScriptObject   builtinStringIteratorPrototype;
 
     /*
      * ECMA section 13.2.3 The [[ThrowTypeError]] Function Object
@@ -1673,7 +1822,58 @@
     }
 
     ScriptObject getSymbolPrototype() {
-        return ScriptFunction.getPrototype(builtinSymbol);
+        return ScriptFunction.getPrototype(getBuiltinSymbol());
+    }
+
+    ScriptObject getMapPrototype() {
+        return ScriptFunction.getPrototype(getBuiltinMap());
+    }
+
+    ScriptObject getWeakMapPrototype() {
+        return ScriptFunction.getPrototype(getBuiltinWeakMap());
+    }
+
+    ScriptObject getSetPrototype() {
+        return ScriptFunction.getPrototype(getBuiltinSet());
+    }
+
+    ScriptObject getWeakSetPrototype() {
+        return ScriptFunction.getPrototype(getBuiltinWeakSet());
+    }
+
+    ScriptObject getIteratorPrototype() {
+        if (builtinIteratorPrototype == null) {
+            builtinIteratorPrototype = initPrototype("AbstractIterator", getObjectPrototype());
+        }
+        return builtinIteratorPrototype;
+    }
+
+    ScriptObject getMapIteratorPrototype() {
+        if (builtinMapIteratorPrototype == null) {
+            builtinMapIteratorPrototype = initPrototype("MapIterator", getIteratorPrototype());
+        }
+        return builtinMapIteratorPrototype;
+    }
+
+    ScriptObject getSetIteratorPrototype() {
+        if (builtinSetIteratorPrototype == null) {
+            builtinSetIteratorPrototype = initPrototype("SetIterator", getIteratorPrototype());
+        }
+        return builtinSetIteratorPrototype;
+    }
+
+    ScriptObject getArrayIteratorPrototype() {
+        if (builtinArrayIteratorPrototype == null) {
+            builtinArrayIteratorPrototype = initPrototype("ArrayIterator", getIteratorPrototype());
+        }
+        return builtinArrayIteratorPrototype;
+    }
+
+    ScriptObject getStringIteratorPrototype() {
+        if (builtinStringIteratorPrototype == null) {
+            builtinStringIteratorPrototype = initPrototype("StringIterator", getIteratorPrototype());
+        }
+        return builtinStringIteratorPrototype;
     }
 
     private synchronized ScriptFunction getBuiltinArrayBuffer() {
@@ -1916,6 +2116,41 @@
         return this.builtinURIError;
     }
 
+    private synchronized ScriptFunction getBuiltinSymbol() {
+        if (this.builtinSymbol == null) {
+            this.builtinSymbol = initConstructorAndSwitchPoint("Symbol", ScriptFunction.class);
+        }
+        return this.builtinSymbol;
+    }
+
+    private synchronized ScriptFunction getBuiltinMap() {
+        if (this.builtinMap == null) {
+            this.builtinMap = initConstructorAndSwitchPoint("Map", ScriptFunction.class);
+        }
+        return this.builtinMap;
+    }
+
+    private synchronized ScriptFunction getBuiltinWeakMap() {
+        if (this.builtinWeakMap == null) {
+            this.builtinWeakMap = initConstructorAndSwitchPoint("WeakMap", ScriptFunction.class);
+        }
+        return this.builtinWeakMap;
+    }
+
+    private synchronized ScriptFunction getBuiltinSet() {
+        if (this.builtinSet == null) {
+            this.builtinSet = initConstructorAndSwitchPoint("Set", ScriptFunction.class);
+        }
+        return this.builtinSet;
+    }
+
+    private synchronized ScriptFunction getBuiltinWeakSet() {
+        if (this.builtinWeakSet == null) {
+            this.builtinWeakSet = initConstructorAndSwitchPoint("WeakSet", ScriptFunction.class);
+        }
+        return this.builtinWeakSet;
+    }
+
     @Override
     public String getClassName() {
         return "global";
@@ -2311,14 +2546,6 @@
         this.builtinString    = initConstructorAndSwitchPoint("String", ScriptFunction.class);
         this.builtinMath      = initConstructorAndSwitchPoint("Math", ScriptObject.class);
 
-        if (env._es6) {
-            this.builtinSymbol = initConstructorAndSwitchPoint("Symbol", ScriptFunction.class);
-        } else {
-            // We need to manually delete nasgen-generated properties we don't want
-            this.delete("Symbol", false);
-            this.builtinObject.delete("getOwnPropertySymbols", false);
-        }
-
         // initialize String.prototype.length to 0
         // add String.prototype.length
         final ScriptObject stringPrototype = getStringPrototype();
@@ -2328,6 +2555,25 @@
         final ScriptObject arrayPrototype = getArrayPrototype();
         arrayPrototype.setIsArray();
 
+        if (env._es6) {
+            this.symbol   = LAZY_SENTINEL;
+            this.map      = LAZY_SENTINEL;
+            this.weakMap  = LAZY_SENTINEL;
+            this.set      = LAZY_SENTINEL;
+            this.weakSet  = LAZY_SENTINEL;
+        } else {
+            // We need to manually delete nasgen-generated properties we don't want
+            this.delete("Symbol", false);
+            this.delete("Map", false);
+            this.delete("WeakMap", false);
+            this.delete("Set", false);
+            this.delete("WeakSet", false);
+            builtinObject.delete("getOwnPropertySymbols", false);
+            arrayPrototype.delete("entries", false);
+            arrayPrototype.delete("keys", false);
+            arrayPrototype.delete("values", false);
+        }
+
         // Error stuff
         initErrorObjects();
 
@@ -2522,7 +2768,6 @@
         this.string            = this.builtinString;
         this.syntaxError       = this.builtinSyntaxError;
         this.typeError         = this.builtinTypeError;
-        this.symbol            = this.builtinSymbol;
     }
 
     private void initDebug() {
@@ -2558,7 +2803,7 @@
     private <T extends ScriptObject> T initConstructor(final String name, final Class<T> clazz) {
         try {
             // Assuming class name pattern for built-in JS constructors.
-            final StringBuilder sb = new StringBuilder("jdk.nashorn.internal.objects.");
+            final StringBuilder sb = new StringBuilder(PACKAGE_PREFIX);
 
             sb.append("Native");
             sb.append(name);
@@ -2586,6 +2831,22 @@
         }
     }
 
+    private ScriptObject initPrototype(final String name, final ScriptObject prototype) {
+        try {
+            // Assuming class name pattern for JS prototypes
+            final String className = PACKAGE_PREFIX + name + "$Prototype";
+
+            final Class<?> funcClass = Class.forName(className);
+            final ScriptObject res = (ScriptObject) funcClass.newInstance();
+
+            res.setIsBuiltin();
+            res.setInitialProto(prototype);
+            return res;
+        } catch (final ClassNotFoundException | InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     private List<jdk.nashorn.internal.runtime.Property> extractBuiltinProperties(final String name, final ScriptObject func) {
         final List<jdk.nashorn.internal.runtime.Property> list = new ArrayList<>();
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/IteratorResult.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.objects.annotations.Property;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+
+@ScriptClass("IteratorResult")
+public class IteratorResult extends ScriptObject {
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    IteratorResult(final Object value, final Boolean done, final Global global) {
+        super(global.getObjectPrototype(), $nasgenmap$);
+        this.value = value;
+        this.done = done;
+    }
+
+    /**
+     * The result value property.
+     */
+    @Property
+    public Object value;
+
+    /**
+     * The result status property.
+     */
+    @Property
+    public Object done;
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/LinkedMap.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.runtime.Undefined;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <p>A linked hash map used by the ES6 Map and Set objects. As required by the ECMA specification for these objects,
+ * this class allows arbitrary modifications to the base collection while being iterated over. However, note that
+ * such modifications are only safe from the same thread performing the iteration; the class is not thread-safe.</p>
+ *
+ * <p>Deletions and additions that occur during iteration are reflected in the elements visited by the iterator
+ * (except for deletion of elements that have already been visited). In non-concurrent Java collections such as
+ * {@code java.util.LinkedHashMap} this would result in a {@link java.util.ConcurrentModificationException}
+ * being thrown.</p>
+ *
+ * <p>This class is implemented using a {@link java.util.HashMap} as backing storage with doubly-linked
+ * list nodes as values.</p>
+ *
+ * @see <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-map.prototype.foreach">Map.prototype.forEach</a>
+ * @see <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-set.prototype.foreach">Set.prototype.forEach</a>
+ */
+public class LinkedMap {
+
+    // We use a plain hash map as our hash storage.
+    private final Map<Object, Node> data = new HashMap<>();
+
+    // The head and tail of our doubly-linked list. We use the same node to represent both the head and the
+    // tail of the list, so the list is circular. This node is never unlinked and thus always remain alive.
+    private final Node head = new Node();
+
+    /**
+     * A node of a linked list that is used as value in our map. The linked list uses insertion order
+     * and allows fast iteration over its element even while the map is modified.
+     */
+    static class Node {
+        private final Object key;
+        private final Object value;
+
+        private volatile boolean alive = true;
+        private volatile Node prev;
+        private volatile Node next;
+
+        /**
+         * Constructor for the list head. This creates an empty circular list.
+         */
+        private Node() {
+            this(null, null);
+            this.next = this;
+            this.prev = this;
+        }
+
+        /**
+         * Constructor for value nodes.
+         *
+         * @param key the key
+         * @param value the value
+         */
+        private Node(final Object key, final Object value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        /**
+         * Get the node's key.
+         * @return the hash key
+         */
+        public Object getKey() {
+            return key;
+        }
+
+        /**
+         * Get the node's value.
+         * @return the value
+         */
+        public Object getValue() {
+            return value;
+        }
+    }
+
+    /**
+     * An iterator over the elements in the map.
+     */
+    class LinkedMapIterator {
+
+        private Node cursor;
+
+        private LinkedMapIterator() {
+            this.cursor = head;
+        }
+
+        /**
+         * Get the next node in this iteration. Changes in the underlying map are reflected in the iteration
+         * as required by the ES6 specification. Note that this method could return a deleted node if deletion
+         * occurred concurrently on another thread.
+         *
+         * @return the next node
+         */
+        public Node next() {
+
+            if (cursor != null) {
+                // If last node is not alive anymore (i.e. has been deleted) go back to the last live node
+                // and continue from there. This may be the list head, which always remains alive.
+                while (!cursor.alive) {
+                    assert cursor != head;
+                    cursor = cursor.prev;
+                }
+
+                cursor = cursor.next;
+
+                if (cursor == head) {
+                    cursor = null; // We've come full circle to the end
+                }
+            }
+
+            return cursor;
+        }
+    }
+
+    /**
+     * Add a key-value pair to the map.
+     * @param key the key
+     * @param value the value
+     */
+    public void set(final Object key, final Object value) {
+        final Node newNode = new Node(key, value);
+        final Node oldNode = data.put(key, newNode);
+        if (oldNode != null) {
+            unlink(oldNode);
+        }
+        link(newNode);
+    }
+
+    /**
+     * Get the value associated with {@code key}.
+     * @param key the key
+     * @return the associated value, or {@code null} if {@code key} is not contained in the map
+     */
+    public Object get(final Object key) {
+        final Node node = data.get(key);
+        return node == null ? Undefined.getUndefined() : node.getValue();
+    }
+
+    /**
+     * Returns {@code true} if {@code key} is contained in the map.
+     * @param key the key
+     * @return {@code true} if {@code key} is contained
+     */
+    public boolean has(final Object key) {
+        return data.containsKey(key);
+    }
+
+    /**
+     * Delete the node associated with {@code key} from the map.
+     * @param key the key
+     * @return {@code true} if {@code key} was contained in the map
+     */
+    public boolean delete (final Object key) {
+        final Node node = data.remove(key);
+        if (node != null) {
+            unlink(node);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Remove all key-value pairs from the map.
+     */
+    public void clear() {
+        data.clear();
+        for (Node node = head.next; node != head; node = node.next) {
+            node.alive = false;
+        }
+        head.next = head;
+        head.prev = head;
+    }
+
+    /**
+     * Return the current number of key-value pairs in the map.
+     * @return the map size
+     */
+    public int size() {
+        return data.size();
+    }
+
+    /**
+     * Get an iterator over the key-value pairs in the map.
+     * @return an iterator
+     */
+    public LinkedMapIterator getIterator() {
+        return new LinkedMapIterator();
+    }
+
+    private void link(final Node newNode) {
+        // We always insert at the end (head == tail)
+        newNode.next = head;
+        newNode.prev = head.prev;
+        newNode.prev.next = newNode;
+        head.prev = newNode;
+    }
+
+    private void unlink(final Node oldNode) {
+        // Note that we unlink references to the node being deleted, but keep the references from the deleted node.
+        // This is necessary to allow iterators to go back to the last live node in case the current node has been
+        // deleted. Also, the forward link of a deleted node may still be followed by an iterator and must not be null.
+        oldNode.prev.next = oldNode.next;
+        oldNode.next.prev = oldNode.prev;
+        oldNode.alive = false;
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/MapIterator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * ECMA6 23.1.5 Map Iterator Objects
+ */
+@ScriptClass("MapIterator")
+public class MapIterator extends AbstractIterator {
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private LinkedMap.LinkedMapIterator iterator;
+
+    private final IterationKind iterationKind;
+
+    // Cached global needed for each iteration result
+    private final Global global;
+
+    /**
+     * Constructor for Map iterators.
+     * @param map the map to iterate over
+     * @param iterationKind the iteration kind
+     * @param global the current global object
+     */
+    MapIterator(final NativeMap map, final IterationKind iterationKind, final Global global) {
+        super(global.getMapIteratorPrototype(), $nasgenmap$);
+        this.iterator = map.getJavaMap().getIterator();
+        this.iterationKind = iterationKind;
+        this.global = global;
+    }
+
+    /**
+     * ES6 23.1.5.2.1 %MapIteratorPrototype%.next()
+     *
+     * @param self the self reference
+     * @param arg the argument
+     * @return the next result
+     */
+    @Function
+    public static Object next(final Object self, final Object arg) {
+        if (!(self instanceof MapIterator)) {
+            throw typeError("not.a.map.iterator", ScriptRuntime.safeToString(self));
+        }
+        return ((MapIterator)self).next(arg);
+    }
+
+    @Override
+    public String getClassName() {
+        return "Map Iterator";
+    }
+
+    @Override
+    protected  IteratorResult next(final Object arg) {
+        if (iterator == null) {
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        final LinkedMap.Node node = iterator.next();
+
+        if (node == null) {
+            iterator = null;
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        if (iterationKind == IterationKind.KEY_VALUE) {
+            final NativeArray array = new NativeArray(new Object[] {node.getKey(), node.getValue()});
+            return makeResult(array, Boolean.FALSE, global);
+        }
+
+        return makeResult(iterationKind == IterationKind.KEY ? node.getKey() : node.getValue(), Boolean.FALSE, global);
+    }
+
+}
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeArray.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeArray.java	Mon Feb 15 17:02:32 2016 +0100
@@ -1718,6 +1718,50 @@
     }
 
     /**
+     * ECMA6 22.1.3.4 Array.prototype.entries ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the array's entries
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object entries(final Object self) {
+        return new ArrayIterator(Global.toObject(self), AbstractIterator.IterationKind.KEY_VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 22.1.3.13 Array.prototype.keys ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the array's keys
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object keys(final Object self) {
+        return new ArrayIterator(Global.toObject(self), AbstractIterator.IterationKind.KEY, Global.instance());
+    }
+
+    /**
+     * ECMA6 22.1.3.29 Array.prototype.values ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the array's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object values(final Object self) {
+        return new ArrayIterator(Global.toObject(self), AbstractIterator.IterationKind.VALUE, Global.instance());
+    }
+
+    /**
+     * 22.1.3.30 Array.prototype [ @@iterator ] ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the array's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, name = "@@iterator")
+    public static Object getIterator(final Object self) {
+        return new ArrayIterator(Global.toObject(self), AbstractIterator.IterationKind.VALUE, Global.instance());
+    }
+
+    /**
      * Determine if Java bulk array operations may be used on the underlying
      * storage. This is possible only if the object's prototype chain is empty
      * or each of the prototypes in the chain is empty.
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeMap.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import java.lang.invoke.MethodHandle;
+
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Constructor;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.Getter;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.objects.annotations.Where;
+import jdk.nashorn.internal.runtime.ConsString;
+import jdk.nashorn.internal.runtime.JSType;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+import jdk.nashorn.internal.runtime.linker.Bootstrap;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * This implements the ECMA6 Map object.
+ */
+@ScriptClass("Map")
+public class NativeMap extends ScriptObject {
+
+    // our underlying map
+    private final LinkedMap map = new LinkedMap();
+
+    // key for the forEach invoker callback
+    private final static Object FOREACH_INVOKER_KEY = new Object();
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private NativeMap(final ScriptObject proto, final PropertyMap map) {
+        super(proto, map);
+    }
+
+    /**
+     * ECMA6 23.1.1 The Map Constructor
+     *
+     * @param isNew is this called with the new operator?
+     * @param self self reference
+     * @param arg optional iterable argument
+     * @return  a new Map instance
+     */
+    @Constructor(arity = 0)
+    public static Object construct(final boolean isNew, final Object self, final Object arg) {
+        if (!isNew) {
+            throw typeError("constructor.requires.new", "Map");
+        }
+        final Global global = Global.instance();
+        final NativeMap map = new NativeMap(global.getMapPrototype(), $nasgenmap$);
+        populateMap(map.getJavaMap(), arg, global);
+        return map;
+    }
+
+    /**
+     * ECMA6 23.1.3.1 Map.prototype.clear ( )
+     *
+     * @param self the self reference
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static void clear(final Object self) {
+        getNativeMap(self).map.clear();
+    }
+
+    /**
+     * ECMA6 23.1.3.3 Map.prototype.delete ( key )
+     *
+     * @param self the self reference
+     * @param key the key to delete
+     * @return true if the key was deleted
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean delete(final Object self, final Object key) {
+        return getNativeMap(self).map.delete(convertKey(key));
+    }
+
+    /**
+     * ECMA6 23.1.3.7 Map.prototype.has ( key )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @return true if key is contained
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean has(final Object self, final Object key) {
+        return getNativeMap(self).map.has(convertKey(key));
+    }
+
+    /**
+     * ECMA6 23.1.3.9 Map.prototype.set ( key , value )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @param value the value
+     * @return this Map object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object set(final Object self, final Object key, final Object value) {
+        getNativeMap(self).map.set(convertKey(key), value);
+        return self;
+    }
+
+    /**
+     * ECMA6 23.1.3.6 Map.prototype.get ( key )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @return the associated value or undefined
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object get(final Object self, final Object key) {
+        return getNativeMap(self).map.get(convertKey(key));
+    }
+
+    /**
+     * ECMA6 23.1.3.10 get Map.prototype.size
+     *
+     * @param self the self reference
+     * @return the size of the map
+     */
+    @Getter(attributes = Attribute.NOT_ENUMERABLE | Attribute.IS_ACCESSOR, where = Where.PROTOTYPE)
+    public static int size(final Object self) {
+        return getNativeMap(self).map.size();
+    }
+
+    /**
+     * ECMA6 23.1.3.4 Map.prototype.entries ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Map's entries
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object entries(final Object self) {
+        return new MapIterator(getNativeMap(self), AbstractIterator.IterationKind.KEY_VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.1.3.8 Map.prototype.keys ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Map's keys
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object keys(final Object self) {
+        return new MapIterator(getNativeMap(self), AbstractIterator.IterationKind.KEY, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.1.3.11 Map.prototype.values ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Map's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object values(final Object self) {
+        return new MapIterator(getNativeMap(self), AbstractIterator.IterationKind.VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.1.3.12 Map.prototype [ @@iterator ]( )
+     *
+     * @param self the self reference
+     * @return An iterator over the Map's entries
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, name = "@@iterator")
+    public static Object getIterator(final Object self) {
+        return new MapIterator(getNativeMap(self), AbstractIterator.IterationKind.KEY_VALUE, Global.instance());
+    }
+
+    /**
+     *
+     * @param self the self reference
+     * @param callbackFn the callback function
+     * @param thisArg optional this-object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, arity = 1)
+    public static void forEach(final Object self, final Object callbackFn, final Object thisArg) {
+        final NativeMap map = getNativeMap(self);
+        if (!Bootstrap.isCallable(callbackFn)) {
+            throw typeError("not.a.function", ScriptRuntime.safeToString(callbackFn));
+        }
+        final MethodHandle invoker = Global.instance().getDynamicInvoker(FOREACH_INVOKER_KEY,
+                () -> Bootstrap.createDynamicCallInvoker(Object.class, Object.class, Object.class, Object.class, Object.class, Object.class));
+
+        final LinkedMap.LinkedMapIterator iterator = map.getJavaMap().getIterator();
+        for (;;) {
+            final LinkedMap.Node node = iterator.next();
+            if (node == null) {
+                break;
+            }
+
+            try {
+                final Object result = invoker.invokeExact(callbackFn, thisArg, node.getValue(), node.getKey(), self);
+            } catch (final RuntimeException | Error e) {
+                throw e;
+            } catch (final Throwable t) {
+                throw new RuntimeException(t);
+            }
+        }
+    }
+
+    @Override
+    public String getClassName() {
+        return "Map";
+    }
+
+    static void populateMap(final LinkedMap map, final Object arg, final Global global) {
+        if (arg != null && arg != Undefined.getUndefined()) {
+            AbstractIterator.iterate(arg, global, value -> {
+                if (JSType.isPrimitive(value)) {
+                    throw typeError(global, "not.an.object", ScriptRuntime.safeToString(value));
+                }
+                if (value instanceof ScriptObject) {
+                    final ScriptObject sobj = (ScriptObject) value;
+                    map.set(convertKey(sobj.get(0)), sobj.get(1));
+                }
+            });
+        }
+    }
+
+    /**
+     * Returns a canonicalized key object by converting numbers to their narrowest representation and
+     * ConsStrings to strings. Conversion of Double to Integer also takes care of converting -0 to 0
+     * as required by step 6 of ECMA6 23.1.3.9.
+     *
+     * @param key a key
+     * @return the canonical key
+     */
+    static Object convertKey(final Object key) {
+        if (key instanceof ConsString) {
+            return key.toString();
+        }
+        if (key instanceof Double) {
+            final Double d = (Double) key;
+            if (JSType.isRepresentableAsInt(d.doubleValue())) {
+                return d.intValue();
+            }
+        }
+        return key;
+    }
+
+    /**
+     * Get the underlying Java map.
+     * @return the Java map
+     */
+    LinkedMap getJavaMap() {
+        return map;
+    }
+
+    private static NativeMap getNativeMap(final Object self) {
+        if (self instanceof NativeMap) {
+            return (NativeMap)self;
+        } else {
+            throw typeError("not.a.map", ScriptRuntime.safeToString(self));
+        }
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeSet.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import java.lang.invoke.MethodHandle;
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Constructor;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.Getter;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.objects.annotations.Where;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+import jdk.nashorn.internal.runtime.linker.Bootstrap;
+
+import static jdk.nashorn.internal.objects.NativeMap.convertKey;
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * This implements the ECMA6 Set object.
+ */
+@ScriptClass("Set")
+public class NativeSet extends ScriptObject {
+
+    // our set/map implementation
+    private final LinkedMap map = new LinkedMap();
+
+    // Invoker for the forEach callback
+    private final static Object FOREACH_INVOKER_KEY = new Object();
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private NativeSet(final ScriptObject proto, final PropertyMap map) {
+        super(proto, map);
+    }
+
+    /**
+     * ECMA6 23.1 Set constructor
+     *
+     * @param isNew  whether the new operator used
+     * @param self self reference
+     * @param arg optional iterable argument
+     * @return a new Set object
+     */
+    @Constructor(arity = 0)
+    public static Object construct(final boolean isNew, final Object self, final Object arg){
+        if (!isNew) {
+            throw typeError("constructor.requires.new", "Set");
+        }
+        final Global global = Global.instance();
+        final NativeSet set = new NativeSet(global.getSetPrototype(), $nasgenmap$);
+        populateSet(set.getJavaMap(), arg, global);
+        return set;
+    }
+
+    /**
+     * ECMA6 23.2.3.1 Set.prototype.add ( value )
+     *
+     * @param self the self reference
+     * @param value the value to add
+     * @return this Set object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object add(final Object self, final Object value) {
+        getNativeSet(self).map.set(convertKey(value), null);
+        return self;
+    }
+
+    /**
+     * ECMA6 23.2.3.7 Set.prototype.has ( value )
+     *
+     * @param self the self reference
+     * @param value the value
+     * @return true if value is contained
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean has(final Object self, final Object value) {
+        return getNativeSet(self).map.has(convertKey(value));
+    }
+
+    /**
+     * ECMA6 23.2.3.2 Set.prototype.clear ( )
+     *
+     * @param self the self reference
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static void clear(final Object self) {
+        getNativeSet(self).map.clear();
+    }
+
+    /**
+     * ECMA6 23.2.3.4 Set.prototype.delete ( value )
+     *
+     * @param self the self reference
+     * @param value the value
+     * @return true if value was deleted
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean delete(final Object self, final Object value) {
+        return getNativeSet(self).map.delete(convertKey(value));
+    }
+
+    /**
+     * ECMA6 23.2.3.9 get Set.prototype.size
+     *
+     * @param self the self reference
+     * @return the number of contained values
+     */
+    @Getter(attributes = Attribute.NOT_ENUMERABLE | Attribute.IS_ACCESSOR, where = Where.PROTOTYPE)
+    public static int size(final Object self) {
+        return getNativeSet(self).map.size();
+    }
+
+    /**
+     * ECMA6 23.2.3.5 Set.prototype.entries ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Set object's entries
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object entries(final Object self) {
+        return new SetIterator(getNativeSet(self), AbstractIterator.IterationKind.KEY_VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.2.3.8 Set.prototype.keys ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Set object's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object keys(final Object self) {
+        return new SetIterator(getNativeSet(self), AbstractIterator.IterationKind.KEY, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.2.3.10 Set.prototype.values ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Set object's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object values(final Object self) {
+        return new SetIterator(getNativeSet(self), AbstractIterator.IterationKind.VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.2.3.11 Set.prototype [ @@iterator ] ( )
+     *
+     * @param self the self reference
+     * @return an iterator over the Set object's values
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, name = "@@iterator")
+    public static Object getIterator(final Object self) {
+        return new SetIterator(getNativeSet(self), AbstractIterator.IterationKind.VALUE, Global.instance());
+    }
+
+    /**
+     * ECMA6 23.2.3.6 Set.prototype.forEach ( callbackfn [ , thisArg ] )
+     *
+     * @param self the self reference
+     * @param callbackFn the callback function
+     * @param thisArg optional this object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, arity = 1)
+    public static void forEach(final Object self, final Object callbackFn, final Object thisArg) {
+        final NativeSet set = getNativeSet(self);
+        if (!Bootstrap.isCallable(callbackFn)) {
+            throw typeError("not.a.function", ScriptRuntime.safeToString(callbackFn));
+        }
+        final MethodHandle invoker = Global.instance().getDynamicInvoker(FOREACH_INVOKER_KEY,
+                () -> Bootstrap.createDynamicCallInvoker(Object.class, Object.class, Object.class, Object.class, Object.class, Object.class));
+
+        final LinkedMap.LinkedMapIterator iterator = set.getJavaMap().getIterator();
+        for (;;) {
+            final LinkedMap.Node node = iterator.next();
+            if (node == null) {
+                break;
+            }
+
+            try {
+                final Object result = invoker.invokeExact(callbackFn, thisArg, node.getKey(), node.getKey(), self);
+            } catch (final RuntimeException | Error e) {
+                throw e;
+            } catch (final Throwable t) {
+                throw new RuntimeException(t);
+            }
+        }
+    }
+
+    @Override
+    public String getClassName() {
+        return "Set";
+    }
+
+    static void populateSet(final LinkedMap map, final Object arg, final Global global) {
+        if (arg != null && arg != Undefined.getUndefined()) {
+            AbstractIterator.iterate(arg, global, value -> map.set(convertKey(value), null));
+        }
+    }
+
+    LinkedMap getJavaMap() {
+        return map;
+    }
+
+    private static NativeSet getNativeSet(final Object self) {
+        if (self instanceof NativeSet) {
+            return (NativeSet) self;
+        } else {
+            throw typeError("not.a.set", ScriptRuntime.safeToString(self));
+        }
+    }
+}
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeString.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeString.java	Mon Feb 15 17:02:32 2016 +0100
@@ -1228,6 +1228,17 @@
     }
 
     /**
+     * ECMA 6 21.1.3.27 String.prototype [ @@iterator ]( )
+     *
+     * @param self self reference
+     * @return a string iterator
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE, name = "@@iterator")
+    public static Object getIterator(final Object self) {
+        return new StringIterator(checkObjectToString(self), Global.instance());
+    }
+
+    /**
      * Lookup the appropriate method for an invoke dynamic call.
      *
      * @param request  the link request
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeSymbol.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeSymbol.java	Mon Feb 15 17:02:32 2016 +0100
@@ -37,6 +37,8 @@
 import jdk.nashorn.internal.objects.annotations.Attribute;
 import jdk.nashorn.internal.objects.annotations.Constructor;
 import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.Getter;
+import jdk.nashorn.internal.objects.annotations.Property;
 import jdk.nashorn.internal.objects.annotations.ScriptClass;
 import jdk.nashorn.internal.objects.annotations.Where;
 import jdk.nashorn.internal.runtime.JSType;
@@ -66,6 +68,12 @@
     /** See ES6 19.4.2.1 */
     private static WeakValueCache<String, Symbol> globalSymbolRegistry = new WeakValueCache<>();
 
+    /**
+     * ECMA 6 19.4.2.4 Symbol.iterator
+     */
+    @Property(where = Where.CONSTRUCTOR, attributes = Attribute.NON_ENUMERABLE_CONSTANT, name = "iterator")
+    public static final Symbol iterator = new Symbol("Symbol.iterator");
+
     NativeSymbol(final Symbol symbol) {
         this(symbol, Global.instance());
     }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeWeakMap.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Constructor;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.JSType;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+import static jdk.nashorn.internal.runtime.JSType.isPrimitive;
+
+/**
+ * This implements the ECMA6 WeakMap object.
+ */
+@ScriptClass("WeakMap")
+public class NativeWeakMap extends ScriptObject {
+
+    private final Map<Object, Object> jmap = new WeakHashMap<>();
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private NativeWeakMap(final ScriptObject proto, final PropertyMap map) {
+        super(proto, map);
+    }
+
+    /**
+     * ECMA6 23.3.1 The WeakMap Constructor
+     *
+     * @param isNew  whether the new operator used
+     * @param self self reference
+     * @param arg optional iterable argument
+     * @return a new WeakMap object
+     */
+    @Constructor(arity = 0)
+    public static Object construct(final boolean isNew, final Object self, final Object arg) {
+        if (!isNew) {
+            throw typeError("constructor.requires.new", "WeakMap");
+        }
+        final Global global = Global.instance();
+        final NativeWeakMap weakMap = new NativeWeakMap(global.getWeakMapPrototype(), $nasgenmap$);
+        populateMap(weakMap.jmap, arg, global);
+        return weakMap;
+    }
+
+    /**
+     * ECMA6 23.3.3.5 WeakMap.prototype.set ( key , value )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @param value the value
+     * @return this WeakMap object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object set(final Object self, final Object key, final Object value) {
+        final NativeWeakMap map = getMap(self);
+        map.jmap.put(checkKey(key), value);
+        return self;
+    }
+
+    /**
+     * ECMA6 23.3.3.3 WeakMap.prototype.get ( key )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @return the associated value or undefined
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object get(final Object self, final Object key) {
+        final NativeWeakMap map = getMap(self);
+        if (isPrimitive(key)) {
+            return Undefined.getUndefined();
+        }
+        return map.jmap.get(key);
+    }
+
+    /**
+     * ECMA6 23.3.3.2 WeakMap.prototype.delete ( key )
+     *
+     * @param self the self reference
+     * @param key the key to delete
+     * @return true if the key was deleted
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean delete(final Object self, final Object key) {
+        final Map<Object, Object> map = getMap(self).jmap;
+        if (isPrimitive(key)) {
+            return false;
+        }
+        final boolean returnValue = map.containsKey(key);
+        map.remove(key);
+        return returnValue;
+    }
+
+    /**
+     * ECMA6 23.3.3.4 WeakMap.prototype.has ( key )
+     *
+     * @param self the self reference
+     * @param key the key
+     * @return true if key is contained
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean has(final Object self, final Object key) {
+        final NativeWeakMap map = getMap(self);
+        return !isPrimitive(key) && map.jmap.containsKey(key);
+    }
+
+    @Override
+    public String getClassName() {
+        return "WeakMap";
+    }
+
+    /**
+     * Make sure {@code key} is not a JavaScript primitive value.
+     *
+     * @param key a key object
+     * @return the valid key
+     */
+    static Object checkKey(final Object key) {
+        if (isPrimitive(key)) {
+            throw typeError("invalid.weak.key", ScriptRuntime.safeToString(key));
+        }
+        return key;
+    }
+
+    static void populateMap(final Map<Object, Object> map, final Object arg, final Global global) {
+        // This method is similar to NativeMap.populateMap, but it uses a different
+        // map implementation and the checking/conversion of keys differs as well.
+        if (arg != null && arg != Undefined.getUndefined()) {
+            AbstractIterator.iterate(arg, global, value -> {
+                if (isPrimitive(value)) {
+                    throw typeError(global, "not.an.object", ScriptRuntime.safeToString(value));
+                }
+                if (value instanceof ScriptObject) {
+                    final ScriptObject sobj = (ScriptObject) value;
+                    map.put(checkKey(sobj.get(0)), sobj.get(1));
+                }
+            });
+        }
+    }
+
+    private static NativeWeakMap getMap(final Object self) {
+        if (self instanceof NativeWeakMap) {
+            return (NativeWeakMap)self;
+        } else {
+            throw typeError("not.a.weak.map", ScriptRuntime.safeToString(self));
+        }
+    }
+
+}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeWeakSet.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+import jdk.nashorn.internal.objects.annotations.Attribute;
+import jdk.nashorn.internal.objects.annotations.Constructor;
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.JSType;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptObject;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.objects.NativeWeakMap.checkKey;
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+import static jdk.nashorn.internal.runtime.JSType.isPrimitive;
+
+/**
+ * This implements the ECMA6 WeakSet object.
+ */
+@ScriptClass("WeakSet")
+public class NativeWeakSet extends ScriptObject {
+
+    private final Map<Object, Boolean> map = new WeakHashMap<>();
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private NativeWeakSet(final ScriptObject proto, final PropertyMap map) {
+        super(proto, map);
+    }
+
+    /**
+     * ECMA6 23.3.1 The WeakSet Constructor
+     *
+     * @param isNew  whether the new operator used
+     * @param self self reference
+     * @param arg optional iterable argument
+     * @return a new WeakSet object
+     */
+    @Constructor(arity = 0)
+    public static Object construct(final boolean isNew, final Object self, final Object arg) {
+        if (!isNew) {
+            throw typeError("constructor.requires.new", "WeakSet");
+        }
+        final Global global = Global.instance();
+        final NativeWeakSet weakSet = new NativeWeakSet(global.getWeakSetPrototype(), $nasgenmap$);
+        populateWeakSet(weakSet.map, arg, global);
+        return weakSet;
+    }
+
+    /**
+     * ECMA6 23.4.3.1 WeakSet.prototype.add ( value )
+     *
+     * @param self the self reference
+     * @param value the value to add
+     * @return this Set object
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static Object add(final Object self, final Object value) {
+        final NativeWeakSet set = getSet(self);
+        set.map.put(checkKey(value), Boolean.TRUE);
+        return self;
+    }
+
+    /**
+     * ECMA6 23.4.3.4 WeakSet.prototype.has ( value )
+     *
+     * @param self the self reference
+     * @param value the value
+     * @return true if value is contained
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean has(final Object self, final Object value) {
+        final NativeWeakSet set = getSet(self);
+        return !isPrimitive(value) && set.map.containsKey(value);
+    }
+
+    /**
+     * ECMA6 23.4.3.3 WeakSet.prototype.delete ( value )
+     *
+     * @param self the self reference
+     * @param value the value
+     * @return true if value was deleted
+     */
+    @Function(attributes = Attribute.NOT_ENUMERABLE)
+    public static boolean delete(final Object self, final Object value) {
+        final Map<Object, Boolean> map = getSet(self).map;
+        if (isPrimitive(value)) {
+            return false;
+        }
+        final boolean returnValue = map.containsKey(value);
+        map.remove(value);
+        return returnValue;
+    }
+
+    @Override
+    public String getClassName() {
+        return "WeakSet";
+    }
+
+    static void populateWeakSet(final Map<Object, Boolean> set, final Object arg, final Global global) {
+        if (arg != null && arg != Undefined.getUndefined()) {
+            AbstractIterator.iterate(arg, global, value -> {
+                    set.put(checkKey(value), Boolean.TRUE);
+            });
+        }
+    }
+
+    private static NativeWeakSet getSet(final Object self) {
+        if (self instanceof NativeWeakSet) {
+            return (NativeWeakSet) self;
+        } else {
+            throw typeError("not.a.weak.set", ScriptRuntime.safeToString(self));
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/SetIterator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * ECMA6 23.2.5 Set Iterator Objects
+ */
+@ScriptClass("SetIterator")
+public class SetIterator extends AbstractIterator {
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private LinkedMap.LinkedMapIterator iterator;
+
+    private final IterationKind iterationKind;
+
+    // Cached global needed for every iteration result
+    private final Global global;
+
+    SetIterator(final NativeSet set, final IterationKind iterationKind, final Global global) {
+        super(global.getSetIteratorPrototype(), $nasgenmap$);
+        this.iterator = set.getJavaMap().getIterator();
+        this.iterationKind = iterationKind;
+        this.global = global;
+    }
+
+    /**
+     * ES6 23.2.5.2.1 %SetIteratorPrototype%.next()
+     *
+     * @param self the self reference
+     * @param arg the argument
+     * @return the next result
+     */
+    @Function
+    public static Object next(final Object self, final Object arg) {
+        if (!(self instanceof SetIterator)) {
+            throw typeError("not.a.set.iterator", ScriptRuntime.safeToString(self));
+        }
+        return ((SetIterator)self).next(arg);
+    }
+
+    @Override
+    public String getClassName() {
+        return "Set Iterator";
+    }
+
+    @Override
+    protected  IteratorResult next(final Object arg) {
+        if (iterator == null) {
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        final LinkedMap.Node node = iterator.next();
+
+        if (node == null) {
+            iterator = null;
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        if (iterationKind == IterationKind.KEY_VALUE) {
+            final NativeArray array = new NativeArray(new Object[] {node.getKey(), node.getKey()});
+            return makeResult(array, Boolean.FALSE, global);
+        }
+
+        return makeResult(node.getKey(), Boolean.FALSE, global);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/StringIterator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.nashorn.internal.objects;
+
+import jdk.nashorn.internal.objects.annotations.Function;
+import jdk.nashorn.internal.objects.annotations.ScriptClass;
+import jdk.nashorn.internal.runtime.PropertyMap;
+import jdk.nashorn.internal.runtime.ScriptRuntime;
+import jdk.nashorn.internal.runtime.Undefined;
+
+import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
+
+/**
+ * ECMA6 21.1.5 String Iterator Objects
+ */
+@ScriptClass("StringIterator")
+public class StringIterator extends AbstractIterator {
+
+    // initialized by nasgen
+    private static PropertyMap $nasgenmap$;
+
+    private String iteratedString;
+    private int nextIndex = 0;
+    private final Global global;
+
+    StringIterator(final String iteratedString, final Global global) {
+        super(global.getStringIteratorPrototype(), $nasgenmap$);
+        this.iteratedString = iteratedString;
+        this.global = global;
+    }
+
+    /**
+     * ES6 21.1.5.2.1 %StringIteratorPrototype%.next()
+     *
+     * @param self the self reference
+     * @param arg the argument
+     * @return the next result
+     */
+    @Function
+    public static Object next(final Object self, final Object arg) {
+        if (!(self instanceof StringIterator)) {
+            throw typeError("not.a.string.iterator", ScriptRuntime.safeToString(self));
+        }
+        return ((StringIterator)self).next(arg);
+    }
+
+    @Override
+    public String getClassName() {
+        return "String Iterator";
+    }
+
+    @Override
+    protected IteratorResult next(final Object arg) {
+        final int index = nextIndex;
+        final String string = iteratedString;
+
+        if (string == null || index >= string.length()) {
+            // ES6 21.1.5.2.1 step 8
+            iteratedString = null;
+            return makeResult(Undefined.getUndefined(), Boolean.TRUE, global);
+        }
+
+        final char first = string.charAt(index);
+        if (first >= 0xd800 && first <= 0xdbff && index < string.length() - 1) {
+            final char second = string.charAt(index + 1);
+            if (second >= 0xdc00 && second <= 0xdfff) {
+                nextIndex += 2;
+                return makeResult(String.valueOf(new char[] {first, second}), Boolean.FALSE, global);
+            }
+        }
+
+        nextIndex++;
+        return makeResult(String.valueOf(first), Boolean.FALSE, global);
+    }
+}
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/annotations/Attribute.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/annotations/Attribute.java	Mon Feb 15 17:02:32 2016 +0100
@@ -31,21 +31,31 @@
  */
 
 public interface Attribute {
-    /** flag for non writable objects */
+    /** Flag for non-writable properties */
     public static final int NOT_WRITABLE     = jdk.nashorn.internal.runtime.Property.NOT_WRITABLE;
 
-    /** flag for non enumerable objects */
+    /** Flag for non-enumerable properties */
     public static final int NOT_ENUMERABLE   = jdk.nashorn.internal.runtime.Property.NOT_ENUMERABLE;
 
-    /** flag for non configurable objects */
+    /** Flag for non-configurable properties */
     public static final int NOT_CONFIGURABLE = jdk.nashorn.internal.runtime.Property.NOT_CONFIGURABLE;
 
-    /** read-only, non-configurable property */
+    /**
+     * Flag for accessor (getter/setter) properties as opposed to data properties.
+     *
+     * <p>This allows nasgen-created properties to behave like user-accessors. it should only be used for
+     * properties that are explicitly specified as accessor properties in the ECMAScript specification
+     * such as Map.prototype.size in ES6, not value properties that happen to be implemented by getter/setter
+     * such as the "length" properties of String or Array objects.</p>
+     */
+    public static final int IS_ACCESSOR = jdk.nashorn.internal.runtime.Property.IS_ACCESSOR_PROPERTY;
+
+    /** Read-only, non-configurable property */
     public static final int CONSTANT = NOT_WRITABLE | NOT_CONFIGURABLE;
 
-    /** non-enumerable, read-only, non-configurable property */
+    /** Non-enumerable, read-only, non-configurable property */
     public static final int NON_ENUMERABLE_CONSTANT = NOT_ENUMERABLE | CONSTANT;
 
-    /** by default properties are writable, enumerable and configurable */
+    /** By default properties are writable, enumerable and configurable */
     public static final int DEFAULT_ATTRIBUTES = 0;
 }
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/AccessorProperty.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/AccessorProperty.java	Mon Feb 15 17:02:32 2016 +0100
@@ -127,7 +127,7 @@
      *
      * @return  New {@link AccessorProperty} created.
      */
-    public static AccessorProperty create(final String key, final int propertyFlags, final MethodHandle getter, final MethodHandle setter) {
+    public static AccessorProperty create(final Object key, final int propertyFlags, final MethodHandle getter, final MethodHandle setter) {
         return new AccessorProperty(key, propertyFlags, -1, getter, setter);
     }
 
@@ -602,6 +602,11 @@
     }
 
     @Override
+    public boolean hasNativeSetter() {
+        return objectSetter != null;
+    }
+
+    @Override
     public MethodHandle getSetter(final Class<?> type, final PropertyMap currentMap) {
         checkUndeclared();
 
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/FindProperty.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/FindProperty.java	Mon Feb 15 17:02:32 2016 +0100
@@ -163,7 +163,7 @@
      * @return appropriate receiver
      */
     public ScriptObject getGetterReceiver() {
-        return property != null && property instanceof UserAccessorProperty ? self : prototype;
+        return property != null && property.isAccessorProperty() ? self : prototype;
     }
 
     /**
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Property.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Property.java	Mon Feb 15 17:02:32 2016 +0100
@@ -99,6 +99,9 @@
     /** Does this property support dual field representation? */
     public static final int DUAL_FIELDS             = 1 << 11;
 
+    /** Is this an accessor property as as defined in ES5 8.6.1? */
+    public static final int IS_ACCESSOR_PROPERTY    = 1 << 12;
+
     /** Property key. */
     private final Object key;
 
@@ -496,6 +499,16 @@
     public abstract void setValue(final ScriptObject self, final ScriptObject owner, final Object value, final boolean strict);
 
     /**
+     * Returns true if this property has a low-level setter handle. This can be used to determine whether a
+     * nasgen-generated accessor property should be treated as non-writable. For user-created accessor properties
+     * {@link #hasSetterFunction(ScriptObject)} should be used to find whether a setter function exists in
+     * a given object.
+     *
+     * @return true if a native setter handle exists
+     */
+    public abstract boolean hasNativeSetter();
+
+    /**
      * Abstract method for retrieving the setter for the property. We do not know
      * anything about the internal representation when we request the setter, we only
      * know that the setter will take the property as a parameter of the given type.
@@ -693,4 +706,12 @@
     public boolean hasDualFields() {
         return (flags & DUAL_FIELDS) != 0;
     }
+
+    /**
+     * Is this an accessor property as defined in ES5 8.6.1?
+     * @return true if this is an accessor property
+     */
+    public boolean isAccessorProperty() {
+        return (flags & IS_ACCESSOR_PROPERTY) != 0;
+    }
 }
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/PropertyMap.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/PropertyMap.java	Mon Feb 15 17:02:32 2016 +0100
@@ -702,10 +702,8 @@
     private boolean allFrozen() {
         for (final Property property : properties.getProperties()) {
             // check if it is a data descriptor
-            if (!(property instanceof UserAccessorProperty)) {
-                if (property.isWritable()) {
-                    return false;
-                }
+            if (!property.isAccessorProperty() && property.isWritable()) {
+                return false;
             }
             if (property.isConfigurable()) {
                return false;
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptFunction.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptFunction.java	Mon Feb 15 17:02:32 2016 +0100
@@ -612,7 +612,7 @@
      *
      * @param newPrototype new prototype object
      */
-    public synchronized final void setPrototype(final Object newPrototype) {
+    public final void setPrototype(final Object newPrototype) {
         if (newPrototype instanceof ScriptObject && newPrototype != this.prototype && allocatorMap != null) {
             // Unset allocator map to be replaced with one matching the new prototype.
             allocatorMap = null;
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptObject.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptObject.java	Mon Feb 15 17:02:32 2016 +0100
@@ -468,7 +468,7 @@
             final boolean enumerable   = property.isEnumerable();
             final boolean writable     = property.isWritable();
 
-            if (property instanceof UserAccessorProperty) {
+            if (property.isAccessorProperty()) {
                 return global.newAccessorDescriptor(
                     get != null ?
                         get :
@@ -910,10 +910,9 @@
     }
 
     private void erasePropertyValue(final Property property) {
-        // Erase the property field value with undefined. If the property is defined
-        // by user-defined accessors, we don't want to call the setter!!
-        if (!(property instanceof UserAccessorProperty)) {
-            assert property != null;
+        // Erase the property field value with undefined. If the property is an accessor property
+        // we don't want to call the setter!!
+        if (property != null && !property.isAccessorProperty()) {
             property.setValue(this, this, UNDEFINED, false);
         }
     }
@@ -996,7 +995,7 @@
             assert gs != null;
             //reuse existing getter setter for speed
             gs.set(getter, setter);
-            if (uc.getFlags() == propertyFlags) {
+            if (uc.getFlags() == (propertyFlags | Property.IS_ACCESSOR_PROPERTY)) {
                 return oldProperty;
             }
             newProperty = new UserAccessorProperty(uc.getKey(), propertyFlags, slot);
@@ -2022,7 +2021,7 @@
         } else if (!find.isSelf()) {
             assert mh.type().returnType().equals(returnType) :
                     "return type mismatch for getter " + mh.type().returnType() + " != " + returnType;
-            if (!(property instanceof UserAccessorProperty)) {
+            if (!property.isAccessorProperty()) {
                 // Add a filter that replaces the self object with the prototype owning the property.
                 mh = addProtoFilter(mh, find.getProtoChainLength());
             }
@@ -2185,7 +2184,7 @@
         FindProperty find = findProperty(name, true, this);
 
         // If it's not a scope search, then we don't want any inherited properties except those with user defined accessors.
-        if (find != null && find.isInherited() && !(find.getProperty() instanceof UserAccessorProperty)) {
+        if (find != null && find.isInherited() && !find.getProperty().isAccessorProperty()) {
             // We should still check if inherited data property is not writable
             if (isExtensible() && !find.getProperty().isWritable()) {
                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "property.not.writable", true);
@@ -2201,9 +2200,13 @@
                 if (NashornCallSiteDescriptor.isScope(desc) && find.getProperty().isLexicalBinding()) {
                     throw typeError("assign.constant", name); // Overwriting ES6 const should throw also in non-strict mode.
                 }
-                // Existing, non-writable property
+                // Existing, non-writable data property
                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "property.not.writable", true);
             }
+            if (!find.getProperty().hasNativeSetter()) {
+                // Existing accessor property without setter
+                return createEmptySetMethod(desc, explicitInstanceOfCheck, "property.has.no.setter", true);
+            }
         } else {
             if (!isExtensible()) {
                 return createEmptySetMethod(desc, explicitInstanceOfCheck, "object.non.extensible", false);
@@ -3040,7 +3043,7 @@
 
         invalidateGlobalConstant(key);
 
-        if (f != null && f.isInherited() && !(f.getProperty() instanceof UserAccessorProperty)) {
+        if (f != null && f.isInherited() && !f.getProperty().isAccessorProperty()) {
             final boolean isScope = isScopeFlag(callSiteFlags);
             // If the start object of the find is not this object it means the property was found inside a
             // 'with' statement expression (see WithObject.findProperty()). In this case we forward the 'set'
@@ -3061,12 +3064,14 @@
         }
 
         if (f != null) {
-            if (!f.getProperty().isWritable()) {
+            if (!f.getProperty().isWritable() || !f.getProperty().hasNativeSetter()) {
                 if (isScopeFlag(callSiteFlags) && f.getProperty().isLexicalBinding()) {
                     throw typeError("assign.constant", key.toString()); // Overwriting ES6 const should throw also in non-strict mode.
                 }
                 if (isStrictFlag(callSiteFlags)) {
-                    throw typeError("property.not.writable", key.toString(), ScriptRuntime.safeToString(this));
+                    throw typeError(
+                            f.getProperty().isAccessorProperty() ? "property.has.no.setter" : "property.not.writable",
+                            key.toString(), ScriptRuntime.safeToString(this));
                 }
                 return;
             }
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/SetMethodCreator.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/SetMethodCreator.java	Mon Feb 15 17:02:32 2016 +0100
@@ -54,7 +54,7 @@
     /**
      * Creates a new property setter method creator.
      * @param sobj the object for which we're creating the property setter
-     * @param find a result of a {@link ScriptObject#findProperty(String, boolean)} on the object for the property we
+     * @param find a result of a {@link ScriptObject#findProperty(Object, boolean)} on the object for the property we
      * want to create a setter for. Can be null if the property does not yet exist on the object.
      * @param desc the descriptor of the call site that triggered the property setter lookup
      * @param request the link request
@@ -66,7 +66,6 @@
         this.desc    = desc;
         this.type    = desc.getMethodType().parameterType(1);
         this.request = request;
-
     }
 
     private String getName() {
@@ -172,7 +171,7 @@
         assert property     != null;
 
         final MethodHandle boundHandle;
-        if (!(property instanceof UserAccessorProperty) && find.isInherited()) {
+        if (!property.isAccessorProperty() && find.isInherited()) {
             boundHandle = ScriptObject.addProtoFilter(methodHandle, find.getProtoChainLength());
         } else {
             boundHandle = methodHandle;
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/UserAccessorProperty.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/UserAccessorProperty.java	Mon Feb 15 17:02:32 2016 +0100
@@ -119,7 +119,8 @@
      * @param slot  spill slot
      */
     UserAccessorProperty(final Object key, final int flags, final int slot) {
-        super(key, flags, slot);
+        // Always set accessor property flag for this class
+        super(key, flags | IS_ACCESSOR_PROPERTY, slot);
     }
 
     private UserAccessorProperty(final UserAccessorProperty property) {
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/linker/PrimitiveLookup.java	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/linker/PrimitiveLookup.java	Mon Feb 15 17:02:32 2016 +0100
@@ -42,7 +42,6 @@
 import jdk.nashorn.internal.runtime.JSType;
 import jdk.nashorn.internal.runtime.ScriptObject;
 import jdk.nashorn.internal.runtime.ScriptRuntime;
-import jdk.nashorn.internal.runtime.UserAccessorProperty;
 
 /**
  * Implements lookup of methods to link for dynamic operations on JavaScript primitive values (booleans, strings, and
@@ -118,7 +117,7 @@
                     return new GuardedInvocation(GlobalConstants.staticConstantGetter(find.getObjectValue()), guard, sp, null);
                 }
 
-                if (find.isInherited() && !(find.getProperty() instanceof UserAccessorProperty)) {
+                if (find.isInherited() && !(find.getProperty().isAccessorProperty())) {
                     // If property is found in the prototype object bind the method handle directly to
                     // the proto filter instead of going through wrapper instantiation below.
                     final ScriptObject proto = wrappedReceiver.getProto();
@@ -180,9 +179,13 @@
         // See ES5.1 8.7.2 PutValue (V, W)
         final String name = JSType.toString(key);
         final FindProperty find = wrappedSelf.findProperty(name, true);
-        if (find == null || !(find.getProperty() instanceof UserAccessorProperty) || !find.getProperty().isWritable()) {
+        if (find == null || !find.getProperty().isAccessorProperty() || !find.getProperty().hasNativeSetter()) {
             if (strict) {
-                throw typeError("property.not.writable", name, ScriptRuntime.safeToString(self));
+                if (find == null || !find.getProperty().isAccessorProperty()) {
+                    throw typeError("property.not.writable", name, ScriptRuntime.safeToString(self));
+                } else {
+                    throw typeError("property.has.no.setter", name, ScriptRuntime.safeToString(self));
+                }
             }
             return;
         }
--- a/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/resources/Messages.properties	Fri Feb 12 17:00:54 2016 +0100
+++ b/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/resources/Messages.properties	Mon Feb 15 17:02:32 2016 +0100
@@ -82,6 +82,14 @@
 type.error.not.a.function={0} is not a function
 type.error.not.a.function.value={0}, which has value {1}, is not a function
 type.error.not.a.constructor={0} is not a constructor function
+type.error.not.a.map={0} is not a Map object
+type.error.not.a.set={0} is not a Set object
+type.error.not.a.weak.map={0} is not a WeakMap object
+type.error.not.a.weak.set={0} is not a WeakSet object
+type.error.not.a.map.iterator={0} is not a Map iterator
+type.error.not.a.set.iterator={0} is not a Set iterator
+type.error.not.a.array.iterator={0} is not an Array iterator
+type.error.not.a.string.iterator={0} is not a String iterator
 type.error.not.a.file={0} is not a File
 type.error.not.a.numeric.array={0} is not a numeric array
 type.error.not.a.bytebuffer={0} is not a java.nio.ByteBuffer
@@ -122,6 +130,7 @@
 type.error.assign.constant=Assignment to constant "{0}"
 type.error.cannot.get.default.string=Cannot get default string value
 type.error.cannot.get.default.number=Cannot get default number value
+type.error.cannot.get.iterator=Cannot get iterator from {1}
 type.error.cant.apply.with.to.null=Cannot apply "with" to null
 type.error.cant.apply.with.to.undefined=Cannot apply "with" to undefined
 type.error.cant.apply.with.to.non.scriptobject=Cannot apply "with" to non script object. Consider using "with(Object.bindProperties('{'}, nonScriptObject))".
@@ -154,7 +163,7 @@
 type.error.java.array.conversion.failed=Java.to conversion to array type {0} failed
 type.error.constructor.requires.new=Constructor {0} requires "new".
 type.error.new.on.nonpublic.javatype=new cannot be used with non-public java type {0}.
-type.error.invalid.weak.key=invalid value {0} used as weak key.
+type.error.invalid.weak.key=primitive value {0} used as weak key.
 type.error.symbol.to.string=Can not convert Symbol value to string.
 type.error.symbol.to.number=Can not convert Symbol value to number.
 type.error.not.a.symbol={0} is not a symbol.
--- a/test/script/basic/es6.js	Fri Feb 12 17:00:54 2016 +0100
+++ b/test/script/basic/es6.js	Mon Feb 15 17:02:32 2016 +0100
@@ -28,13 +28,21 @@
  * @run
  */
 
-if (typeof Symbol !== 'undefined' || 'Symbol' in this) {
-    Assert.fail('Symbol is defined in global scope');
+function checkUndefined(name, object) {
+    if (typeof object[name] !== 'undefined' || name in object) {
+        Assert.fail(name + ' is defined in ' + object);
+    }
 }
 
-if (typeof Object.getOwnPropertySymbols !== 'undefined' || 'getOwnPropertySymbols' in Object) {
-    Assert.fail('getOwnPropertySymbols is defined in global Object');
-}
+checkUndefined('Symbol', this);
+checkUndefined('Map', this);
+checkUndefined('Set', this);
+checkUndefined('WeakMap', this);
+checkUndefined('WeakSet', this);
+checkUndefined('getOwnPropertySymbols', Object);
+checkUndefined('entries', Array.prototype);
+checkUndefined('values', Array.prototype);
+checkUndefined('keys', Array.prototype);
 
 function expectError(src, msg, error) {
     try {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/script/basic/es6/iterator.js	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * JDK-8147558: Add support for ES6 collections
+ *
+ * @test
+ * @run
+ * @option --language=es6
+ */
+
+
+function testIterator(iter, expectedValues) {
+    let next;
+
+    for (var i = 0; i < expectedValues.length; i++) {
+        next = iter.next();
+        Assert.assertTrue(next.done === false);
+
+        if (Array.isArray(expectedValues[i])) {
+            Assert.assertTrue(Array.isArray(next.value));
+            Assert.assertTrue(next.value.length === expectedValues[i].length);
+            Assert.assertTrue(next.value.every(function(v, j) {
+                return v === expectedValues[i][j];
+            }));
+
+        } else {
+            Assert.assertTrue(next.value === expectedValues[i]);
+        }
+    }
+
+    next = iter.next();
+    Assert.assertTrue(next.done === true);
+    Assert.assertTrue(next.value === undefined);
+}
+
+const str = "abcdefg";
+const array = ["a", "b", "c", "d", "e", "f", "g"];
+const arrayKeys = [0, 1, 2, 3, 4, 5, 6];
+const setEntries = [["a", "a"], ["b", "b"], ["c", "c"], ["d", "d"], ["e", "e"], ["f", "f"], ["g", "g"]];
+const mapEntries = [["a", "A"], ["b", "B"], ["c", "C"], ["d", "D"], ["e", "E"], ["f", "F"], ["g", "G"]];
+const mapValues = ["A", "B", "C", "D", "E", "F", "G"];
+const arrayEntries = [[0, "a"], [1, "b"], [2, "c"], [3, "d"], [4, "e"], [5, "f"], [6, "g"]];
+
+// Set iterator tests
+const set = new Set(str);
+testIterator(set[Symbol.iterator](), str);
+testIterator(set.values(), str);
+testIterator(set.keys(), str);
+testIterator(set.entries(), setEntries);
+
+// Map iterator tests
+const map = new Map(mapEntries);
+testIterator(map[Symbol.iterator](), mapEntries);
+testIterator(map.values(), mapValues);
+testIterator(map.keys(), array);
+testIterator(map.entries(), mapEntries);
+
+// String iterator tests
+testIterator(str[Symbol.iterator](), str);
+
+// Array iterator tests
+testIterator(array[Symbol.iterator](), array);
+testIterator(array.values(), array);
+testIterator(array.keys(), arrayKeys);
+testIterator(array.entries(), arrayEntries);
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/script/basic/es6/map.js	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * 
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ * 
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * JDK-8147558: Add support for ES6 collections
+ *
+ * @test
+ * @run
+ * @option --language=es6
+ */
+
+function assertThrows(src, error) {
+    try {
+        eval(src);
+        Assert.fail("No error, expected " + error);
+    } catch (e) {
+        if (!(e instanceof error)) {
+            Assert.fail("Wrong error, expected " + error + " but got " + e);
+        }
+    }
+}
+
+// Map constructor and prototype
+
+var desc = Object.getOwnPropertyDescriptor(this, "Map");
+Assert.assertEquals(desc.writable, true);
+Assert.assertEquals(desc.configurable, true);
+Assert.assertEquals(desc.enumerable, false);
+
+Assert.assertTrue(Object.getPrototypeOf(new Map()) === Map.prototype);
+Assert.assertTrue(Object.getPrototypeOf(Map.prototype) === Object.prototype);
+Assert.assertTrue(new Map().size === 0);
+Assert.assertTrue(Object.getPrototypeOf(new Map([["a", 1], ["b", 2]])) === Map.prototype);
+Assert.assertTrue(new Map([["a", 1], ["b", 2]]).size === 2);
+Assert.assertTrue(Object.getPrototypeOf(new Map("")) === Map.prototype);
+Assert.assertTrue(new Map("").size === 0);
+Assert.assertTrue(Object.getPrototypeOf(new Map([])) === Map.prototype);
+Assert.assertTrue(new Map([]).size === 0);
+
+assertThrows("Map()", TypeError);
+assertThrows("new Map(3)", TypeError);
+assertThrows("new Map('abc')", TypeError);
+assertThrows("new Map({})", TypeError);
+assertThrows("new Map([1, 2, 3])", TypeError);
+
+assertThrows("Map.prototype.set.apply({}, ['', ''])", TypeError);
+assertThrows("Map.prototype.get.apply([], [''])", TypeError);
+assertThrows("Map.prototype.has.apply(3, [''])", TypeError);
+assertThrows("Map.prototype.clear.apply('', [])", TypeError);
+
+// Map methods
+
+var m = new Map([["a", 1], ["b", 2]]);
+Assert.assertTrue(m.size, 2);
+Assert.assertTrue(m.get("a") === 1);
+Assert.assertTrue(m.get("b") === 2);
+Assert.assertTrue(m.get("c") === undefined);
+Assert.assertTrue(m.has("a") === true);
+Assert.assertTrue(m.has("b") === true);
+Assert.assertTrue(m.has("c") === false);
+
+m.clear();
+Assert.assertTrue(m.size === 0);
+Assert.assertTrue(m.get("a") === undefined);
+Assert.assertTrue(m.get("b") === undefined);
+Assert.assertTrue(m.get("c") === undefined);
+Assert.assertTrue(m.has("a") === false);
+Assert.assertTrue(m.has("b") === false);
+Assert.assertTrue(m.has("c") === false);
+
+var a = "a", x = "x"; // for ConsString keys
+Assert.assertTrue(m.set("ab", false) === m);
+Assert.assertTrue(m.set(x + "y", m) === m);
+Assert.assertTrue(m.get(a + "b") === false);
+Assert.assertTrue(m.get("xy") === m);
+Assert.assertTrue(m.has(a + "b") === true);
+Assert.assertTrue(m.has("xy") === true);
+
+// Special keys
+
+m = new Map();
+Assert.assertTrue(m.set(NaN, NaN) === m);  // NaN should work as key
+Assert.assertTrue(m.size === 1);
+Assert.assertTrue(isNaN(m.get(NaN)));
+Assert.assertTrue(isNaN(m.keys().next().value));
+Assert.assertTrue(isNaN(m.values().next().value));
+Assert.assertTrue(m.has(NaN) === true);
+Assert.assertTrue(m.delete(NaN));
+Assert.assertTrue(m.size === 0);
+Assert.assertTrue(m.get(NaN) === undefined);
+Assert.assertTrue(m.keys().next().done);
+Assert.assertTrue(m.values().next().done);
+Assert.assertTrue(m.has(NaN) === false);
+
+m.clear();
+m.set(-0, -0); // -0 key should be converted to +0
+Assert.assertTrue(m.size === 1);
+Assert.assertTrue(m.get(-0) === 0);
+Assert.assertTrue(1 / m.keys().next().value === Infinity);
+Assert.assertTrue(1 / m.values().next().value === -Infinity);
+Assert.assertTrue(m.has(-0) === true);
+Assert.assertTrue(m.has(0) === true);
+Assert.assertTrue(m.delete(-0));
+Assert.assertTrue(m.size === 0);
+Assert.assertTrue(m.get(-0) === undefined);
+Assert.assertTrue(m.get(0) === undefined);
+Assert.assertTrue(m.has(-0) === false);
+Assert.assertTrue(m.has(0) === false);
+
+Assert.assertFalse(m.delete("foo"));
+Assert.assertFalse(m.delete(0));
+Assert.assertFalse(m.delete(NaN));
+
+// foreach
+
+m = new Map([[1, "one"], [2, "two"], [3, "three"]]);
+m.forEach(function(value, key, map) {
+    Assert.assertTrue(this === m);
+    Assert.assertTrue(map === m);
+}, m);
+
+function assertEqualArrays(a, b) {
+    Assert.assertTrue(Array.isArray(a));
+    Assert.assertTrue(Array.isArray(b));
+    Assert.assertTrue(a.length === b.length);
+    Assert.assertTrue(a.every(function(v, j) {
+        return v === b[j];
+    }));
+}
+
+let array = [];
+m = new Map([[1, "one"], [2, "two"], [3, "three"]]);
+m.forEach(function(value, key, map) {
+    array.push(value);
+});
+assertEqualArrays(array, ["one", "two", "three"]);
+
+array = [];
+m = new Map([[1, "one"], [2, "two"], [3, "three"]]);
+m.forEach(function(value, key, map) {
+    array.push(value);
+    if (key == 3) {
+        map.clear();
+        map.set(4, "four");
+    }
+});
+assertEqualArrays(array, ["one", "two", "three", "four"]);
+
+array = [];
+m = new Map([[1, "one"], [2, "two"], [3, "three"]]);
+m.forEach(function(value, key, map) {
+    array.push(value);
+    if (key == 1) {
+        map.delete(1);
+    }
+    if (key == 2) {
+        map.delete(3);
+    }
+});
+assertEqualArrays(array, ["one", "two"]);
+
+array = [];
+m = new Map([[1, "one"], [2, "two"], [3, "three"]]);
+m.forEach(function(value, key, map) {
+    array.push(value);
+    if (array.length < 4) {
+        map.delete(key);
+        map.set(key, key + 3)
+    }
+});
+assertEqualArrays(array, ["one", "two", "three", 4, 5, 6]);
+
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/script/basic/es6/set.js	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ * 
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ * 
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ * 
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * JDK-8147558: Add support for ES6 collections
+ *
+ * @test
+ * @run
+ * @option --language=es6
+ */
+
+function assertThrows(src, error) {
+    try {
+        eval(src);
+        Assert.fail("No error, expected " + error);
+    } catch (e) {
+        if (!(e instanceof error)) {
+            Assert.fail("Wrong error, expected " + error + " but got " + e);
+        }
+    }
+}
+
+// Set constructor and prototype
+
+var desc = Object.getOwnPropertyDescriptor(this, "Set");
+Assert.assertEquals(desc.writable, true);
+Assert.assertEquals(desc.configurable, true);
+Assert.assertEquals(desc.enumerable, false);
+
+Assert.assertTrue(Object.getPrototypeOf(new Set()) === Set.prototype);
+Assert.assertTrue(Object.getPrototypeOf(Set.prototype) === Object.prototype);
+Assert.assertTrue(new Set().size === 0);
+Assert.assertTrue(Object.getPrototypeOf(new Set(["a", 3, false])) === Set.prototype);
+Assert.assertTrue(new Set(["a", 3, false]).size === 3);
+Assert.assertTrue(new Set("abc").size === 3);
+Assert.assertTrue(new Set("").size === 0);
+Assert.assertTrue(new Set([]).size === 0);
+
+assertThrows("Set()", TypeError);
+assertThrows("new Set(3)", TypeError);
+assertThrows("new Set({})", TypeError);
+
+assertThrows("Set.prototype.add.apply({}, [''])", TypeError);
+assertThrows("Set.prototype.has.apply(3, [''])", TypeError);
+assertThrows("Set.prototype.delete.apply('', [3])", TypeError);
+
+// Set methods
+
+var s = new Set(["a", 3, false]);
+Assert.assertTrue(s.size, 2);
+Assert.assertTrue(s.has("a") === true);
+Assert.assertTrue(s.has(3) === true);
+Assert.assertTrue(s.has(false) === true);
+
+Assert.assertTrue(s.clear() === undefined);
+Assert.assertTrue(s.size === 0);
+Assert.assertTrue(s.has("a") === false);
+Assert.assertTrue(s.has(3) === false);
+Assert.assertTrue(s.has(false) === false);
+
+var a = "a", x = "x"; // for ConsString keys
+Assert.assertTrue(s.add("ab", false) === s);
+Assert.assertTrue(s.add(x + "y", s) === s);
+Assert.assertTrue(s.has(a + "b") === true);
+Assert.assertTrue(s.has("xy") === true);
+
+// Special keys
+
+s.clear()
+Assert.assertTrue(s.add(NaN) === s);  // NaN should work as key
+Assert.assertTrue(s.size === 1);
+Assert.assertTrue(isNaN(s.keys().next().value));
+Assert.assertTrue(isNaN(s.values().next().value));
+Assert.assertTrue(s.has(NaN) === true);
+Assert.assertTrue(s.delete(NaN) === true);
+Assert.assertTrue(s.size === 0);
+Assert.assertTrue(s.keys().next().done);
+Assert.assertTrue(s.values().next().done);
+Assert.assertTrue(s.has(NaN) === false);
+
+s.clear()
+s.add(-0); // -0 key should be converted to +0
+Assert.assertTrue(s.size === 1);
+Assert.assertTrue(1 / s.keys().next().value === Infinity);
+Assert.assertTrue(1 / s.values().next().value === Infinity);
+Assert.assertTrue(s.has(-0) === true);
+Assert.assertTrue(s.has(0) === true);
+Assert.assertTrue(s.delete(-0) === true);
+Assert.assertTrue(s.size === 0);
+Assert.assertTrue(s.has(-0) === false);
+Assert.assertTrue(s.has(0) === false);
+
+// foreach
+
+s = new Set([1, 2, 3]);
+
+s.forEach(function(value, key, set) {
+    Assert.assertTrue(this === s);
+    Assert.assertTrue(set === s);
+}, s);
+
+function assertEqualArrays(a, b) {
+    Assert.assertTrue(Array.isArray(a));
+    Assert.assertTrue(Array.isArray(b));
+    Assert.assertTrue(a.length === b.length);
+    Assert.assertTrue(a.every(function(v, j) {
+        return v === b[j];
+    }));
+}
+
+let array = [];
+s = new Set([1, 2, 3]);
+s.forEach(function(value, key, set) {
+    array.push(value);
+});
+assertEqualArrays(array, [1, 2, 3]);
+
+array = [];
+s = new Set([1, 2, 3]);
+s.forEach(function(value, key, set) {
+    array.push(value);
+    if (key == 3) {
+        set.clear();
+        set.add("four");
+    }
+});
+assertEqualArrays(array, [1, 2, 3, "four"]);
+
+array = [];
+s = new Set([1, 2, 3]);
+s.forEach(function(value, key, set) {
+    array.push(value);
+    if (key == 1) {
+        set.delete(1);
+    }
+    if (key == 2) {
+        set.delete(3);
+    }
+});
+assertEqualArrays(array, [1, 2]);
+
+array = [];
+s = new Set([1, 2, 3]);
+s.forEach(function(value, key, set) {
+    array.push(value);
+    if (key < 4) {
+        set.delete(key);
+        set.add(key + 3)
+    }
+});
+assertEqualArrays(array, [1, 2, 3, 4, 5, 6]);
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/script/basic/es6/weakmap.js	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * JDK-8147558: Add support for ES6 collections
+ *
+ * @test
+ * @run
+ * @option --language=es6
+ */
+
+function assertThrows(src, error) {
+    try {
+        eval(src);
+        Assert.fail("No error, expected " + error);
+    } catch (e) {
+        if (!(e instanceof error)) {
+            Assert.fail("Wrong error, expected " + error + " but got " + e);
+        }
+    }
+}
+
+// WeakMap constructor and prototype
+
+var desc = Object.getOwnPropertyDescriptor(this, "WeakMap");
+Assert.assertEquals(desc.writable, true);
+Assert.assertEquals(desc.configurable, true);
+Assert.assertEquals(desc.enumerable, false);
+
+Assert.assertTrue(Object.getPrototypeOf(new WeakMap()) === WeakMap.prototype);
+Assert.assertTrue(Object.getPrototypeOf(WeakMap.prototype) === Object.prototype);
+Assert.assertTrue(Object.getPrototypeOf(new WeakMap("")) === WeakMap.prototype);
+Assert.assertTrue(Object.getPrototypeOf(new WeakMap([])) === WeakMap.prototype);
+
+assertThrows("WeakMap()", TypeError);
+assertThrows("new WeakMap(3)", TypeError);
+assertThrows("new WeakMap({})", TypeError);
+assertThrows("new WeakMap([['a', {}]])", TypeError);
+assertThrows("new WeakMap([[3, {}]])", TypeError);
+assertThrows("new WeakMap([[true, {}]])", TypeError);
+assertThrows("new WeakMap([[Symbol.iterator, {}]])", TypeError);
+
+assertThrows("WeakMap.prototype.set.apply({}, [{}, {}])", TypeError);
+assertThrows("WeakMap.prototype.has.apply(3, [{}])", TypeError);
+assertThrows("WeakMap.prototype.delete.apply('', [3])", TypeError);
+
+// WeakMap methods
+
+let values = [[{}, 1], [{}, 2], [{}, 3]];
+let m = new WeakMap(values);
+
+for (let i = 0; i < values.length; i++) {
+    Assert.assertTrue(m.has(values[i][0]) === true);
+    Assert.assertTrue(m.get(values[i][0]) === values[i][1]);
+    Assert.assertTrue(m.delete(values[i][0]) === true);
+    Assert.assertTrue(m.has(values[i][0]) === false);
+}
+
+values.forEach(function(v) {
+    Assert.assertTrue(m.set(v[0], v[1]) === m);
+});
+
+for (let i = 0; i < values.length; i++) {
+    Assert.assertTrue(m.has(values[i][0]) === true);
+    Assert.assertTrue(m.get(values[i][0]) === values[i][1]);
+    Assert.assertTrue(m.delete(values[i][0]) === true);
+    Assert.assertTrue(m.has(values[i][0]) === false);
+}
+
+// Primitive keys
+
+assertThrows("m.set('a', {})", TypeError);
+assertThrows("m.set(3, {})", TypeError);
+assertThrows("m.set(false, {})", TypeError);
+assertThrows("m.set(Symbol.iterator, {})", TypeError);
+
+Assert.assertTrue(m.has('a') === false);
+Assert.assertTrue(m.delete(3) === false);
+Assert.assertTrue(m.get(Symbol.iterator) === undefined);
+Assert.assertTrue(m.get(true) === undefined);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/script/basic/es6/weakset.js	Mon Feb 15 17:02:32 2016 +0100
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * JDK-8147558: Add support for ES6 collections
+ *
+ * @test
+ * @run
+ * @option --language=es6
+ */
+
+function assertThrows(src, error) {
+    try {
+        eval(src);
+        Assert.fail("No error, expected " + error);
+    } catch (e) {
+        if (!(e instanceof error)) {
+            Assert.fail("Wrong error, expected " + error + " but got " + e);
+        }
+    }
+}
+
+// WeakSet constructor and prototype
+
+var desc = Object.getOwnPropertyDescriptor(this, "WeakSet");
+Assert.assertEquals(desc.writable, true);
+Assert.assertEquals(desc.configurable, true);
+Assert.assertEquals(desc.enumerable, false);
+
+Assert.assertTrue(Object.getPrototypeOf(new WeakSet()) === WeakSet.prototype);
+Assert.assertTrue(Object.getPrototypeOf(WeakSet.prototype) === Object.prototype);
+Assert.assertTrue(Object.getPrototypeOf(new WeakSet("")) === WeakSet.prototype);
+Assert.assertTrue(Object.getPrototypeOf(new WeakSet([])) === WeakSet.prototype);
+
+assertThrows("WeakSet()", TypeError);
+assertThrows("new WeakSet(3)", TypeError);
+assertThrows("new WeakSet({})", TypeError);
+assertThrows("new WeakSet(['a'])", TypeError);
+assertThrows("new WeakSet([3])", TypeError);
+assertThrows("new WeakSet([true])", TypeError);
+assertThrows("new WeakSet([Symbol.iterator])", TypeError);
+
+assertThrows("WeakSet.prototype.add.apply({}, [''])", TypeError);
+assertThrows("WeakSet.prototype.has.apply(3, [''])", TypeError);
+assertThrows("WeakSet.prototype.delete.apply('', [3])", TypeError);
+
+// WeakSet methods
+
+let values = [{}, {}, {}];
+let s = new WeakSet(values);
+
+for (let i = 0; i < values.length; i++) {
+    Assert.assertTrue(s.has(values[i]) === true);
+    Assert.assertTrue(s.delete(values[i]) === true);
+    Assert.assertTrue(s.has(values[i]) === false);
+}
+
+values.forEach(function(v) {
+    Assert.assertTrue(s.add(v) === s);
+});
+
+for (let i = 0; i < values.length; i++) {
+    Assert.assertTrue(s.has(values[i]) === true);
+    Assert.assertTrue(s.delete(values[i]) === true);
+    Assert.assertTrue(s.has(values[i]) === false);
+}
+
+// Primitive keys
+
+assertThrows("s.add('a')", TypeError);
+assertThrows("s.add(3)", TypeError);
+assertThrows("s.add(false)", TypeError);
+assertThrows("s.add(Symbol.iterator)", TypeError);
+
+Assert.assertTrue(s.has('a') === false);
+Assert.assertTrue(s.delete(3) === false);
+Assert.assertTrue(s.has(Symbol.iterator) === false);
+Assert.assertTrue(s.delete(true) === false);
+
+