--- old/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/CatchNode.java	2016-11-07 07:20:55.293612441 -0800
+++ new/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/CatchNode.java	2016-11-07 07:20:55.157599960 -0800
@@ -35,8 +35,8 @@
 public final class CatchNode extends Statement {
     private static final long serialVersionUID = 1L;
 
-    /** Exception identifier. */
-    private final IdentNode exception;
+    /** Exception identifier or pattern. */
+    private final Expression exception;
 
     /** Exception condition. */
     private final Expression exceptionCondition;
@@ -52,21 +52,26 @@
      * @param lineNumber         lineNumber
      * @param token              token
      * @param finish             finish
-     * @param exception          variable name of exception
+     * @param exception          variable name or pattern of exception
      * @param exceptionCondition exception condition
      * @param body               catch body
      * @param isSyntheticRethrow true if this node is a synthetically generated rethrow node.
      */
-    public CatchNode(final int lineNumber, final long token, final int finish, final IdentNode exception,
+    public CatchNode(final int lineNumber, final long token, final int finish, final Expression exception,
             final Expression exceptionCondition, final Block body, final boolean isSyntheticRethrow) {
         super(lineNumber, token, finish);
-        this.exception          = exception == null ? null : exception.setIsInitializedHere();
+        if (exception instanceof IdentNode) {
+            this.exception = ((IdentNode) exception == null) ? null : ((IdentNode) exception).setIsInitializedHere();
+        } else {
+            this.exception = exception;
+        }
+
         this.exceptionCondition = exceptionCondition;
-        this.body               = body;
+        this.body = body;
         this.isSyntheticRethrow = isSyntheticRethrow;
     }
 
-    private CatchNode(final CatchNode catchNode, final IdentNode exception, final Expression exceptionCondition,
+    private CatchNode(final CatchNode catchNode, final Expression exception, final Expression exceptionCondition,
             final Block body, final boolean isSyntheticRethrow) {
         super(catchNode);
         this.exception          = exception;
@@ -83,11 +88,10 @@
     public Node accept(final NodeVisitor<? extends LexicalContext> visitor) {
         if (visitor.enterCatchNode(this)) {
             return visitor.leaveCatchNode(
-                setException((IdentNode)exception.accept(visitor)).
-                setExceptionCondition(exceptionCondition == null ? null : (Expression)exceptionCondition.accept(visitor)).
-                setBody((Block)body.accept(visitor)));
+                    setException((Expression) exception.accept(visitor)).
+                            setExceptionCondition(exceptionCondition == null ? null : (Expression) exceptionCondition.accept(visitor)).
+                            setBody((Block) body.accept(visitor)));
         }
-
         return this;
     }
 
@@ -113,7 +117,13 @@
      * @return the exception identifier
      */
     public IdentNode getException() {
-        return exception;
+        //Fixme :http://www.ecma-international.org/ecma-262/6.0/
+        //for now, only parsing is supported
+        if (exception instanceof IdentNode) {
+            return (IdentNode) exception;
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -149,7 +159,7 @@
      * @param exception new exception
      * @return new catch node if changed, same otherwise
      */
-    public CatchNode setException(final IdentNode exception) {
+    public CatchNode setException(final Expression exception) {
         if (this.exception == exception) {
             return this;
         }
--- old/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java	2016-11-07 07:20:55.935671360 -0800
+++ new/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Parser.java	2016-11-07 07:20:55.812660072 -0800
@@ -2607,13 +2607,23 @@
                 next();
                 expect(LPAREN);
 
-                // FIXME: ES6 catch parameter can be a BindingIdentifier or a BindingPattern
-                // We need to generalize this here!
+                // ES6 catch parameter can be a BindingIdentifier or a BindingPattern
                 // http://www.ecma-international.org/ecma-262/6.0/
-                final IdentNode exception = getIdent();
+                final String contextString = "catch argument";
+                final Expression exception = bindingIdentifierOrPattern(contextString);
+                final boolean isDestructuring = !(exception instanceof IdentNode);
+                if (isDestructuring) {
+                    verifyDestructuringBindingPattern(exception, new Consumer<IdentNode>() {
+                        @Override
+                        public void accept(final IdentNode identNode) {
+                            verifyIdent(identNode, contextString);
+                        }
+                    });
+                } else {
+                    // ECMA 12.4.1 strict mode restrictions
+                    verifyStrictIdent((IdentNode) exception, "catch argument");
+                }
 
-                // ECMA 12.4.1 strict mode restrictions
-                verifyStrictIdent(exception, "catch argument");
 
                 // Nashorn extension: catch clause can have optional
                 // condition. So, a single try can have more than one