/*

 * Copyright (c) 2019, 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.

 */

/*

 * @test

 * @bug 8223305 8226522

 * @summary Ensure proper errors are returned for yields.

 * @compile/fail/ref=WrongYieldTest.out --enable-preview -source ${jdk.version} -XDrawDiagnostics -XDshould-stop.at=ATTR WrongYieldTest.java

 */

package t;

//ERROR - type called yield:

import t.WrongYieldTest.yield;

public class WrongYieldTest {

    // ERROR -  class called yield

    class yield { }

    // OK to have fields called yield

    String[] yield = null;

    // ERROR - field of type yield

    yield y;

    // OK to have methods called yield

    // Nullary yield method

    String[] yield() {

        return null;

    }

    // Unary yield method

    String[] yield(int i) {

        return null;

    }

    // Binary yield method

    String[] yield(int i, int j) {

        return null;

    }

    // OK to declare a local called yield

    void LocalDeclaration1() {

       int yield;

    }

    // OK to declare and initialise a local called yield

    void LocalDeclaration2() {

        int yield = 42;

    }

    // ERROR can't refer to a local called yield in the initialiser

    void LocalDeclaration3() {

        int yield = yield + 1;

    }

    // OK yield gets interpreted as an identifier in a local declaration

    void LocalDeclaration4(int i) {

        int local = switch (i) {

            default -> {

                int yield = yield + 1;

                yield 42;

            }

        };

    }

    // OK - yield a local called yield

    void LocalDeclaration5(int i) {

        int yield = 42;

        int temp = switch (i) {

            default -> {

                yield yield;

            }

        };

    }

    void YieldTypedLocals(int i) {

        // ERROR - Parsed as yield statement, and y1 is unknown

        yield y1 = null;

        // ..whereas..

        // ERROR - parsed as yield statement, which has no switch target

        Object y1;

        yield y1 = null;

        // ERROR - Parsed as yield statement, and y2 is unknown

        yield y2 = new yield();

        // OK - Parsed as yield statement that assigns local y

        Object y;

        Object o = switch (i) {

            default :

                yield y = null;

        };

        // ERROR - Parsed as yield statement that assigns local y,

        //but the initializer refers to restricted identifier:

        Object y2;

        Object o2 = switch (i) {

            default :

                yield y2 = new yield();

        };

        // ERROR - can not create an yield-valued local of type Object

        Object y3 = new yield();

        // ERROR - can not create a final yield-valued local of type yield

        final yield y4 = new yield();

        // ERROR - can create a non-final local of type yield using qualified typename

        WrongYieldTest.yield y5 = new yield();

    }

    void MethodInvocation(int i) {

        // OK - can access a field called yield

        String[] x = this.yield;

        // ERROR - calling nullary yield method using simple name parsed as yield statement

        yield();

        // OK - can call nullary yield method using qualified name

        this.yield();

        // ERROR - Calling unary yield method using simple name is parsed as yield statement

        yield(2);

        // OK - calling unary yield method using qualified name

        this.yield(2);

        // ERROR - Calling binary yield method using simple name is parsed as yield statement

        yield(2, 2); //error

        // OK - calling binary yield method using qualified name

        this.yield(2, 2);

        // ERROR - nullary yield method as receiver is parsed as yield statement

        yield().toString();

        // OK - nullary yield method as receiver using qualified name

        this.yield().toString();

        // ERROR - unary yield method as receiver is parsed as yield statement

        yield(2).toString();

        // OK - unary yield method as receiver using qualified name

        this.yield(2).toString();

        // ERROR - binary yield method as receiver is parsed as yield statement

        yield(2, 2).toString();

        // OK - binary yield method as receiver using qualified name

        this.yield(2, 2).toString();

        // OK - yield method call is in an expression position

        String str = yield(2).toString();

        //OK - yield is a variable

        yield.toString();

        // OK - parsed as method call (with qualified local yield as receiver)

        this.yield.toString();

        yield[0].toString(); //error

        // OK - parsed as yield statement in switch expression

        int j = switch (i) {

            default:

                yield(2);

        };

        // ERROR - second yield is an unreachable statement.

        x = switch (i) {

            default: {

                yield x = null;

                yield null;

            }

        };

    }

    private void yieldLocalVar1(int i) {

        int yield = 0;

        //OK - yield is a variable:

        yield++;

        yield--;

        //ERROR - yield is a statement, but no enclosing switch expr:

        yield ++i;

        yield --i;

        //OK - yield is a variable:

        yield = 3;

        //OK - yield is a variable:

        for (int j = 0; j < 3; j++)

            yield += 1;

        //OK - yield is a variable and not at the beginning of the statement:

        yieldLocalVar1(yield);

        //ERROR - unqualified yield method invocation:

        yieldLocalVar1(yield().length);

        yieldLocalVar1(yield.class.getModifiers());

    }

    private void yieldLocalVar2(int i) {

        int[] yield = new int[1];

        //OK - yield is a variable:

        yield[0] = 5;

    }

    private void lambda() {

        SAM s = (yield y) -> {};

    }

    interface SAM {

        public void m(Object o);

    }

}