env GO111MODULE=on
! go build
stderr ' type alias requires'
go mod edit -go=1.9
grep 'go 1.9' go.mod
go build

# Reverting the version should force a rebuild and error instead of using
# the cached 1.9 build. (https://golang.org/issue/37804)
go mod edit -go=1.8
! go build
stderr 'type alias requires'

# go=none should drop the line
go mod edit -go=none
! grep go go.mod

		NewServiceEvaluator(f),
		NewPersistentVolumeClaimEvaluator(f),
	}
	// these evaluators require an alias for backwards compatibility
	for gvr, alias := range legacyObjectCountAliases {
		result = append(result,
			generic.NewObjectCountEvaluator(gvr.GroupResource(), generic.ListResourceUsingListerFunc(f, gvr), alias))
	}
	return result

    public boolean hasDependency(String alias) {
        return libraries.containsKey(normalize(alias));
    }

    public boolean hasBundle(String alias) {
        return bundles.containsKey(normalize(alias));
    }

    public boolean hasVersion(String alias) {
        return versions.containsKey(normalize(alias));
    }

    public boolean hasPlugin(String alias) {

) : PluginDependenciesSpec {

    override fun id(id: String): PluginDependencySpec =
        plugins.id(id)

    override fun alias(notation: Provider<PluginDependency>) =
        plugins.alias(notation)

    override fun alias(notation: ProviderConvertible<PluginDependency>) =
        plugins.alias(notation)
}


/**
 * Specify the version of the plugin to depend on.
 *
 * Infix version of [PluginDependencySpec.version].

			if !alphaFeatures.Has(string(feature)) {
				areAllRequiredFeaturesAlpha = false
				break
			}
		}

		if areAllRequiredFeaturesAlpha {
			t.Errorf("alias check failed: controller name %q should not be aliased as it is still guarded by alpha feature gates (%v) and thus should have only a canonical name", name, requiredFeatureGates)
		}
	}
}

! stderr 'Alias'

-- go.mod --
module example.com
go 1.12

-- a.go --
package a

/*
typedef int T;
*/
import "C"

func (C.T) f() {}
func (recv *C.T) g() {}

// The check is more education than enforcement,
// and is easily defeated using a type alias.
type Alias = C.T
func (Alias) h() {}

  const TensorProto* tensor_proto;
  std::set<std::string> seen_request_inputs;

  for (const auto& [alias, tensor_info] : signature.inputs()) {
    const std::string& feed_name = tensor_info.name();
    auto iter = request_inputs.find(alias);

    if (iter == request_inputs.end()) {
      auto default_inputs_iter = signature.defaults().find(alias);
      if (default_inputs_iter == signature.defaults().end()) {

	{{- range $alias := .Resource.VersionAliases }}
	{{$entry.Resource.Identifier}}_{{$alias}} = schema.GroupVersionResource{Group: "{{$entry.Resource.Group}}", Version: "{{$alias}}", Resource: "{{$entry.Resource.Plural}}"}
    {{- end }}
{{- end }}
)

func IsClusterScoped(g schema.GroupVersionResource) bool {

	} else {
		karatsubaSub(z[n2:], p, n)
	}
}

// alias reports whether x and y share the same base array.
//
// Note: alias assumes that the capacity of underlying arrays
// is never changed for nat values; i.e. that there are
// no 3-operand slice expressions in this code (or worse,
// reflect-based operations to the same effect).
func alias(x, y nat) bool {

function(f,g,h,l,m){this.type=f,this.content=g,this.alias=h,this.length=0|(l||'').length,this.greedy=!!m};if(d.stringify=function(f,g,h){if('string'==typeof f)return f;if('Array'===c.util.type(f))return f.map(function(q){return d.stringify(q,g,f)}).join('');var l={type:f.type,content:d.stringify(f.content,g,h),tag:'span',classes:['token',f.type],attributes:{},language:g,parent:h};if(f.alias){var m='Array'===c.util.type(f.alias)?f.alias:[f.alias];Array.prototype.push.apply(l.classes,m)}c.hooks.run('wrap',l);var...