}

func g() {
	type T3 struct{ T3 } // ERROR "invalid recursive type"
	type _ map[T3]int
}

func h() {
	type T4 struct{ m map[T4]int } // ERROR "invalid map key"
	type _ map[T4]int              // GC_ERROR "invalid map key"

import (
	"fmt"	// ERROR "previous|not used"
	fmt "math"	// ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt|imported as fmt and not used"
	. "math"	// GC_ERROR "imported and not used: \x22math\x22$|imported and not used"

	} else if fitError, ok := err.(*framework.FitError); ok { // Inject UnschedulablePlugins to PodInfo, which will be used later for moving Pods between queues efficiently.
		podInfo.UnschedulablePlugins = fitError.Diagnosis.UnschedulablePlugins
		podInfo.PendingPlugins = fitError.Diagnosis.PendingPlugins

		}
	}

	// Failed to identify what type of error this, return a simple UI error
	return Err{msg: err.Error()}
}

// FmtError converts a fatal error message to a more clear error
// using some colors
func FmtError(introMsg string, err error, jsonFlag bool) string {
	renderedTxt := ""
	uiErr := ErrorToErr(err)
	// JSON print
	if jsonFlag {
		// Message text in json should be simple

// errorcheck

// Copyright 2016 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

import "fmt"  // GC_ERROR "imported and not used"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type t struct {
	x int // GCCGO_ERROR "duplicate field name .x."
	x int // GC_ERROR "duplicate field x|x redeclared"
}

func f(t *t) int {
	return t.x

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 7525: self-referential array types.

package main

var y struct { // GC_ERROR "initialization cycle: y refers to itself"
	d [len(y.d)]int // GCCGO_ERROR "array bound|typechecking loop|invalid array"

// license that can be found in the LICENSE file.

// We have a limit of 1GB for stack frames.
// Make sure we include the callee args section.

package main

type Big = [400e6]byte

func f() { // GC_ERROR "stack frame too large"
	// Note: This test relies on the fact that we currently always
	// spill function-results to the stack, even if they're so
	// large that we would normally heap allocate them. If we ever

// license that can be found in the LICENSE file.

package p

func f1(x *[1<<30 - 1e6]byte) byte {
	for _, b := range *x {
		return b
	}
	return 0
}
func f2(x *[1<<30 + 1e6]byte) byte { // GC_ERROR "stack frame too large"
	for _, b := range *x {
		return b
	}
	return 0

            } else {
                effectivePolicy.merge(policy);
            }
        }

        return effectivePolicy;
    }

    public Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors) {
        return mirrorSelector.getMirror(repository, mirrors);
    }

    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {