val artifacts by lazy {
            files.map { file ->
                val artifactId = ComponentFileArtifactIdentifier(ownerId, file.file.name)
                PreResolvedResolvableArtifact(null, DefaultIvyArtifactName.forFile(file.file, file.classifier), artifactId, file.file, TaskDependencyContainer.EMPTY, calculatedValueContainerFactory)
            }
        }
    }

                                }

                                @Override
                                public IvyArtifactName getArtifactName() {
                                    return DefaultIvyArtifactName.forFile(file, null);
                                }

                                @Override
                                public File getFile() {
                                    return file;

            this.variantAttributes = variantAttributes;
            this.dependencyMetadata = dependencyMetadata;
            artifact = new DefaultResolvableArtifact(null, DefaultIvyArtifactName.forFile(file, null), this.artifactIdentifier, this.dependencyMetadata.getFiles(), calculatedValueContainerFactory.create(Describables.of(artifactIdentifier), file), calculatedValueContainerFactory);
        }

        @Override

        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaScriptSymbol>(this)?.let { return it }

        val firFile = firSymbol.fir.getContainingFile() ?: errorWithAttachment("${FirFile::class.simpleName} is not found") {
            withFirSymbolEntry("script", firSymbol)
        }

        firFile.symbol.let(builder::buildFileSymbol).createPointer().let(::KaFirScriptSymbolPointer)
    }

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirScript

internal class KaFirScriptSymbolPointer(private val filePointer: KaSymbolPointer<KaFileSymbol>) : KaSymbolPointer<KaScriptSymbol>() {

        elementsAll.put(name, newArray);
    }

    protected void addFileParameter(final FileItem item) {
        final MultipartFormFile formFile = newActionMultipartFormFile(item);
        elementsFile.put(item.getFieldName(), formFile);
        elementsAll.put(item.getFieldName(), formFile);
    }

    protected ActionMultipartFormFile newActionMultipartFormFile(final FileItem item) {
        return new ActionMultipartFormFile(item);

import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ContextCollector
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression

		}
	}
}

func testMissingFile(t *testing.T, req *Request) {
	f, fh, err := req.FormFile("missing")
	if f != nil {
		t.Errorf("FormFile file = %v, want nil", f)
	}
	if fh != nil {
		t.Errorf("FormFile file header = %v, want nil", fh)
	}
	if err != ErrMissingFile {
		t.Errorf("FormFile err = %q, want ErrMissingFile", err)
	}
}

func newTestMultipartRequest(t *testing.T) *Request {

        val firFile = ktFile.getOrBuildFirFile(firResolveSession)
        val bindings = JvmSerializationBindings().also { collectBindings(firFile.declarations, mapping, it) }
        val (serializer, stringTable) = createTopLevelSerializer(bindings)
        val fileProto = serializer.packagePartProto(firFile, null)

        }

        return null
    }

    private fun getFullyResolvedFirFile(file: KtFile): FirFile {
        val firFile = file.getOrBuildFirFile(firResolveSession)
        firFile.lazyResolveToPhaseRecursively(FirResolvePhase.BODY_RESOLVE)
        return firFile
    }

    private fun computeErrors(
        diagnostics: Collection<DiagnosticMarker>,