attribute(Attribute.of('other', String), 'foobar')
                        }
                    }.files)
                }
                
                tasks.register('resolveAll', Resolve) {
                    artifacts.from(configurations.producerArtifacts)
                    artifacts.from(configurations.producerArtifacts.incoming.artifactView {
                        withVariantReselection()

        replaceWith = ReplaceWith("resolveCallOld()"),
    )
    public fun KtElement.resolveCall(): KaCallInfo? = resolveCallOld()

    public fun KtElement.resolveCallOld(): KaCallInfo? = withValidityAssertion {
        analysisSession.resolver.resolveCall(this)
    }

    @Deprecated(
        message = "The API will be changed soon. Use 'collectCallCandidatesOld()' in a transit period",

package analysisflags

import (
	"fmt"
	"net/url"

	"golang.org/x/tools/go/analysis"
)

// ResolveURL resolves the URL field for a Diagnostic from an Analyzer
// and returns the URL. See Diagnostic.URL for details.
func ResolveURL(a *analysis.Analyzer, d analysis.Diagnostic) (string, error) {
	if d.URL == "" && d.Category == "" && a.URL == "" {
		return "", nil // do nothing
	}

            return resolveCall(parentBinaryExpression)
        }

        when (psi) {
            is KtCallableReferenceExpression -> return resolveCall(psi.callableReference)
            is KtWhenConditionInRange -> return psi.operationReference.let(::resolveCall)
            is KtConstructorDelegationReferenceExpression -> return (psi.parent as? KtElement)?.let(::resolveCall)
        }

			t0 := time.Now()
			act.result, act.err = a.Run(pass)

			if act.err == nil { // resolve URLs on diagnostics.
				for i := range act.diagnostics {
					if url, uerr := analysisflags.ResolveURL(a, act.diagnostics[i]); uerr == nil {
						act.diagnostics[i].URL = url
					} else {
						act.err = uerr // keep the last error
					}
				}
			}
			if false {

        ) {
            withPsiEntry("reference", reference.element)
        }

        with(reference) {
            return analysisSession.resolveToSymbols()
        }
    }

    override fun resolveCall(psi: KtElement): KaCallInfo? {
        return wrapError(psi) {
            val ktCallInfos = getCallInfo(
                psi,
                getErrorCallInfo = { psiToResolve ->

if(module){var assetPath=module.getAttribute('assetpath')||'';var importURL=Polymer.ResolveUrl.resolveUrl(assetPath,module.ownerDocument.baseURI);this._importPath=Polymer.ResolveUrl.pathFromUrl(importURL);}else{this._importPath='';}