_Go          // go
	_Goto        // goto
	_If          // if
	_Import      // import
	_Interface   // interface
	_Map         // map
	_Package     // package
	_Range       // range
	_Return      // return
	_Select      // select
	_Struct      // struct
	_Switch      // switch
	_Type        // type
	_Var         // var

	// empty line comment to exclude it from .String
	tokenCount //
)

const (

                visitLabel(label2);
                _ALOAD(0);
                _INVOKESPECIAL(OBJECT_TYPE, "toString", RETURN_STRING);
                _ARETURN();
            }});
        }

        private void generateServiceRegistrySupport() {
            // GENERATE private transient ServiceLookup services;

            }});

            //
            // Add `toString()`
            //
            publicMethod("toString", RETURN_STRING, methodVisitor -> new MethodVisitorScope(methodVisitor) {{
                // return this.name
                _ALOAD(0);
                _GETFIELD(generatedTypeName, NAME_FIELD, STRING);
                _ARETURN();
            }});

            //

        //   However, because of the type of the object returned by `getArchiveFile()` is a `Property`,
        //   we assume it's mutable, even though the _return type_ is `Provider`.
        //   We will produce the correct message after https://github.com/gradle/gradle/issues/26141 is fixed.

    }

    public void _ARETURN() {
        super.visitInsn(ARETURN);
    }

    public void _IRETURN_OF(Type type) {
        super.visitInsn(type.getOpcode(IRETURN));
    }

    public void _IRETURN() {
        super.visitInsn(IRETURN);
    }

    public void _RETURN() {
        super.visitInsn(RETURN);
    }

		t.Key = p.type_()
		p.want(_Rbrack)
		t.Value = p.type_()
		return t

	case _Struct:
		return p.structType()

	case _Interface:
		return p.interfaceType()

	case _Name:
		return p.qualifiedName(nil)

	case _Lparen:
		p.next()
		t := p.type_()
		p.want(_Rparen)
		return t
	}

	return nil
}

func (p *parser) typeInstance(typ Expr) Expr {

			fatalf("%v", err)
		}
	}
	return gccgoMangler(ppath)
}

// Return the package prefix when using gccgo.
func (p *Package) gccgoSymbolPrefix() string {
	if !*gccgo {
		return ""
	}

	if *gccgopkgpath != "" {
		return gccgoToSymbol(*gccgopkgpath)
	}
	if *gccgoprefix == "" && p.PackageName == "main" {
		return "main"
	}
	prefix := gccgoToSymbol(*gccgoprefix)

			return true
		}

	case *ast.BlockStmt:
		return check.isTerminatingList(s.List, "")

	case *ast.IfStmt:
		if s.Else != nil &&
			check.isTerminating(s.Body, "") &&
			check.isTerminating(s.Else, "") {
			return true
		}

	case *ast.SwitchStmt:
		return check.isTerminatingSwitch(s.Body, label)

	case *ast.TypeSwitchStmt:
		return check.isTerminatingSwitch(s.Body, label)

	case *ast.SelectStmt:

  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return 1,
    return 2,
    return b
  ]
  returnValueType = kotlin.Int
  valuedReturnExpressions = [
    return 1,
    return 2,
    return b
  ]

fun test(flag: Boolean): Int {
    block {
        <expr>if (flag) {
            return 1
        }

        consume("foo")
        return@block</expr>
    }

    return 0
}

inline fun block(block: () -> Unit) {}