Datasets:

Mlxa

/

java_methods

like 0

TargetTypeBuildScope (final boolean forceBuild) { return createAllTargetsScope(JavaModuleBuildTargetType.PRODUCTION, forceBuild); }

createAllModulesProductionScope

TargetTypeBuildScope (BuildTargetType<?> type, boolean forceBuild) { return TargetTypeBuildScope.newBuilder() .setTypeId(type.getTypeId()) .setAllTargets(true) .setForceBuild(forceBuild) .build(); }

createAllTargetsScope

TargetTypeBuildScope (final String targetTypeId, List<String> targetIds, boolean forceBuild) { return TargetTypeBuildScope.newBuilder().setTypeId(targetTypeId).setForceBuild(forceBuild).addAllTargetId(targetIds).build(); }

createTargetsScope

BuilderMessage (@NotNull String latestDownloadCommit, long decompressionSpeed, long deletionSpeed) { BuilderMessage.CommitAndDownloadStatistics.Builder downloadStatisticsBuilder = BuilderMessage.CommitAndDownloadStatistics.newBuilder(); downloadStatisticsBuilder.setCommit(latestDownloadCommit); downloadStatisticsBuilder.setDecompressionSpeed(decompressionSpeed); downloadStatisticsBuilder.setDeletionSpeed(deletionSpeed); BuilderMessage.Builder newBuilder = BuilderMessage.newBuilder(); newBuilder.setType(BuilderMessage.Type.SAVE_LATEST_DOWNLOAD_STATISTIC_MESSAGE); newBuilder.setCommitAndDownloadStatistics(downloadStatisticsBuilder.build()); return newBuilder.build(); }

createSaveDownloadStatisticMessage

BuilderMessage (String text) { BuilderMessage.CacheDownloadMessage.Builder cacheDownloadMessageBuilder = BuilderMessage.CacheDownloadMessage.newBuilder(); cacheDownloadMessageBuilder.setDescriptionText(text); BuilderMessage.Builder newBuilder = BuilderMessage.newBuilder(); newBuilder.setType(BuilderMessage.Type.CACHE_DOWNLOAD_MESSAGE); newBuilder.setCacheDownloadMessage(cacheDownloadMessageBuilder.build()); return newBuilder.build(); }

createCacheDownloadMessage

BuilderMessage (String text, float progress) { BuilderMessage.CacheDownloadMessage.Builder cacheDownloadMessageBuilder = BuilderMessage.CacheDownloadMessage.newBuilder(); cacheDownloadMessageBuilder.setDescriptionText(text); cacheDownloadMessageBuilder.setDone(progress); BuilderMessage.Builder newBuilder = BuilderMessage.newBuilder(); newBuilder.setType(BuilderMessage.Type.CACHE_DOWNLOAD_MESSAGE); newBuilder.setCacheDownloadMessage(cacheDownloadMessageBuilder.build()); return newBuilder.build(); }

createCacheDownloadMessageWithProgress

BuilderMessage (String builderId, String messageType, String messageText) { BuilderMessage.BuildEvent.CustomBuilderMessage builderMessage = BuilderMessage.BuildEvent.CustomBuilderMessage.newBuilder() .setBuilderId(builderId) .setMessageType(messageType) .setMessageText(messageText) .build(); return createBuildEvent(BuilderMessage.BuildEvent.Type.CUSTOM_BUILDER_MESSAGE, null, null, null, builderMessage); }

createCustomBuilderMessage

BuilderMessage (@Nullable String description, final BuilderMessage.BuildEvent.Status status) { return createBuildEvent(BuilderMessage.BuildEvent.Type.BUILD_COMPLETED, description, status, null, null); }

createBuildCompletedEvent

BuilderMessage (final Collection<? extends Pair<String, String>> paths) { return createBuildEvent(BuilderMessage.BuildEvent.Type.FILES_GENERATED, null, null, paths, null); }

createFileGeneratedEvent

BuilderMessage (final BuilderMessage.BuildEvent.Type type, @Nullable String description, final @Nullable BuilderMessage.BuildEvent.Status status, @Nullable Collection<? extends Pair<String, String>> generatedPaths, final @Nullable BuilderMessage.BuildEvent.CustomBuilderMessage builderMessage) { final BuilderMessage.BuildEvent.Builder builder = BuilderMessage.BuildEvent.newBuilder().setEventType(type); if (description != null) { builder.setDescription(description); } if (status != null) { builder.setCompletionStatus(status); } if (generatedPaths != null) { for (Pair<String, String> pair : generatedPaths) { final BuilderMessage.BuildEvent.GeneratedFile.Builder fileBuilder = BuilderMessage.BuildEvent.GeneratedFile.newBuilder(); final BuilderMessage.BuildEvent.GeneratedFile generatedFile = fileBuilder.setOutputRoot(pair.first).setRelativePath(pair.second).build(); builder.addGeneratedFiles(generatedFile); } } if (builderMessage != null) { builder.setCustomBuilderMessage(builderMessage); } return BuilderMessage.newBuilder().setType(BuilderMessage.Type.BUILD_EVENT).setBuildEvent(builder.build()).build(); }

createBuildEvent

BuilderMessage () { return BuilderMessage.newBuilder().setType(BuilderMessage.Type.PARAM_REQUEST).build(); }

createParamRequest

BuilderMessage () { return BuilderMessage.newBuilder().setType(BuilderMessage.Type.SAVE_LATEST_BUILT_COMMIT_MESSAGE).build(); }

createSaveLatestBuiltCommitMessage

void () { if (!myDone.getAndSet(true)) { mySemaphore.release(); } }

setDone

boolean (boolean mayInterruptIfRunning) { if (isDone()) { return false; } if (!myCanceledState.getAndSet(true)) { try { performCancel(); } catch (Exception e) { throw new RuntimeException(e); } } return true; }

cancel

boolean () { return myCanceledState.get(); }

isCancelled

boolean () { return myDone.get(); }

isDone

void () { try { while (!isDone()) { if (mySemaphore.tryAcquire(100L, TimeUnit.MILLISECONDS)) { mySemaphore.release(); } } } catch (InterruptedException ignored) { } }

waitFor

boolean (long timeout, TimeUnit unit) { try { if (!isDone()) { if (mySemaphore.tryAcquire(timeout, unit)) { mySemaphore.release(); } } } catch (InterruptedException ignored) { } return isDone(); }

waitFor

T () { waitFor(); return null; }

get

void (String filePath, Iterable<Map.Entry<? extends JavacRef, Integer>> refs, Collection<? extends JavacDef> defs, Collection<? extends JavacTypeCast> casts, Collection<? extends JavacRef> implicitToString, final JavaBackwardReferenceIndexWriter writer) { try { final int fileId = writer.enumeratePath(filePath); int funExprId = 0; Map<CompilerRef, Void> definitions = new HashMap<>(defs.size()); Map<CompilerRef, Collection<CompilerRef>> backwardHierarchyMap = new HashMap<>(); Map<SignatureData, Collection<CompilerRef>> signatureData = new HashMap<>(); Map<CompilerRef, Collection<CompilerRef>> castMap = new HashMap<>(); Map<CompilerRef, Void> implicitToStringMap = new HashMap<>(); final AnonymousClassEnumerator anonymousClassEnumerator = new AnonymousClassEnumerator(); for (JavacDef def : defs) { if (def instanceof JavacDef.JavacClassDef) { JavacRef.JavacClass sym = (JavacRef.JavacClass)def.getDefinedElement(); if (sym.isPackageInfo()) { continue; // skip special 'package-info' class } final CompilerRef.CompilerClassHierarchyElementDef aClass; if (sym.isAnonymous()) { final JavacRef[] classes = ((JavacDef.JavacClassDef)def).getSuperClasses(); if (classes.length == 0) { LOG.info("Seems that compilation will finish with errors in anonymous class inside file " + filePath); continue; } aClass = anonymousClassEnumerator.addAnonymous(sym.getName(), writer.asClassUsage(classes[0])); } else { aClass = writer.asClassUsage(sym); } definitions.put(aClass, null); final JavacRef[] superClasses = ((JavacDef.JavacClassDef)def).getSuperClasses(); for (JavacRef superClass : superClasses) { CompilerRef.JavaCompilerClassRef superClassRef = writer.asClassUsage(superClass); backwardHierarchyMap.computeIfAbsent(superClassRef, k -> new SmartList<>()).add(aClass); } } else if (def instanceof JavacDef.JavacFunExprDef) { final CompilerRef.JavaCompilerClassRef functionalType = writer.asClassUsage(def.getDefinedElement()); int id = funExprId++; CompilerRef.JavaCompilerFunExprDef result = new CompilerRef.JavaCompilerFunExprDef(id); definitions.put(result, null); backwardHierarchyMap.computeIfAbsent(functionalType, __ -> new SmartList<>()).add(result); } else if (def instanceof JavacDef.JavacMemberDef) { final CompilerRef ref = writer.enumerateNames(def.getDefinedElement(), name -> anonymousClassEnumerator.getCompilerRefIfAnonymous(name)); final CompilerRef.JavaCompilerClassRef returnType = writer.asClassUsage(((JavacDef.JavacMemberDef)def).getReturnType()); if (ref != null) { final SignatureData data = new SignatureData(returnType.getName(), ((JavacDef.JavacMemberDef)def).getIteratorKind(), ((JavacDef.JavacMemberDef)def).isStatic()); signatureData.computeIfAbsent(data, element -> new SmartList<>()).add(ref); } } } Map<CompilerRef, Integer> convertedRefs = new HashMap<>(); for (Map.Entry<? extends JavacRef, Integer> entry : refs) { JavacRef ref = entry.getKey(); int count = entry.getValue(); CompilerRef compilerRef = writer.enumerateNames(ref, name -> anonymousClassEnumerator.getCompilerRefIfAnonymous(name)); if (compilerRef != null) { convertedRefs.merge(compilerRef, count, (oldValue, value) -> oldValue + value); } } for (JavacTypeCast cast : casts) { CompilerRef enumeratedCastType = writer.enumerateNames(cast.getCastType(), name -> null); if (enumeratedCastType == null) continue; CompilerRef enumeratedOperandType = writer.enumerateNames(cast.getOperandType(), name -> null); if (enumeratedOperandType == null) continue; castMap.computeIfAbsent(enumeratedCastType, t -> new SmartList<>()).add(enumeratedOperandType); } for (JavacRef ref : implicitToString) { implicitToStringMap.put(writer.asClassUsage(ref), null); } writer.writeData(fileId, new CompiledFileData(backwardHierarchyMap, castMap, convertedRefs, definitions, signatureData, implicitToStringMap)); } catch (IOException e) { writer.setRebuildCause(e); } }

registerFile

Integer (String className) { if (myAnonymousName2Id == null) return null; final CompilerRef.CompilerClassHierarchyElementDef ref = myAnonymousName2Id.get(className); return ref == null ? null : ref.getName(); }

getCompilerRefIfAnonymous

int () { return myRawReturnType; }

getRawReturnType

byte () { return myArrayKind; }

getIteratorKind

boolean () { return myStatic; }

isStatic

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; SignatureData data = (SignatureData)o; if (myRawReturnType != data.myRawReturnType) return false; if (myArrayKind != data.myArrayKind) return false; if (myStatic != data.myStatic) return false; return true; }

equals

int () { int result = myRawReturnType; result = 31 * result + myArrayKind; result = 31 * result + (myStatic ? 1 : 0); return result; }

hashCode

JavaBackwardReferenceIndexWriter () { return ourInstance; }

getInstance

void (final @NotNull CompileContext context) { if (ourInstance != null) { return; } final BuildDataManager dataManager = context.getProjectDescriptor().dataManager; final File buildDir = dataManager.getDataPaths().getDataStorageRoot(); if (isEnabled()) { boolean isRebuild = isRebuildInAllJavaModules(context); if (!JavaCompilers.JAVAC_ID.equals(JavaBuilder.getUsedCompilerId(context)) || !JavaBuilder.IS_ENABLED.get(context, Boolean.TRUE)) { CompilerReferenceIndex.removeIndexFiles(buildDir); return; } boolean cleanupOk = true; if (isRebuild) { CompilerReferenceIndex.removeIndexFiles(buildDir); cleanupOk = !CompilerReferenceIndex.exists(buildDir); } else if (CompilerReferenceIndex.versionDiffers(buildDir, JavaCompilerIndices.VERSION)) { CompilerReferenceIndex.removeIndexFiles(buildDir); if ((ourInitAttempt++ == 0 && areAllJavaModulesAffected(context))) { throw new BuildDataCorruptedException("backward reference index will be updated to actual version"); } // do not request a rebuild if a project is affected incompletely and version is changed, just disable indices return; } if (cleanupOk) { ourInstance = new JavaBackwardReferenceIndexWriter(new JavaCompilerBackwardReferenceIndex(buildDir, dataManager.getRelativizer(), false)); ShutDownTracker.getInstance().registerShutdownTask(() -> closeIfNeeded(false)); } } else { CompilerReferenceIndex.removeIndexFiles(buildDir); } }

initialize

boolean () { return SystemProperties.getBooleanProperty(PROP_KEY, false); }

isEnabled

boolean (JavacRef ref) { return ref.getModifiers().contains(Modifier.PRIVATE); }

isPrivate

boolean (CompileContext context) { for (JavaModuleBuildTargetType type : JavaModuleBuildTargetType.ALL_TYPES) { for (ModuleBuildTarget target : context.getProjectDescriptor().getBuildTargetIndex().getAllTargets(type)) { if (!context.getScope().isBuildForced(target)) { return false; } } } return true; }

isRebuildInAllJavaModules

boolean (CompileContext context) { for (JavaModuleBuildTargetType type : JavaModuleBuildTargetType.ALL_TYPES) { for (ModuleBuildTarget target : context.getProjectDescriptor().getBuildTargetIndex().getAllTargets(type)) { if (!context.getScope().isWholeTargetAffected(target)) { return false; } } } return true; }

areAllJavaModulesAffected

int () { return myName; }

getName

CompilerRef (int newOwner) { return new JavaCompilerMethodRef(newOwner, myName, myParameterCount); }

override

int () { return myParameterCount; }

getParameterCount

CompilerClassHierarchyElementDef () { return new JavaCompilerClassRef(myOwner); }

getOwner

void (DataOutput out) { try { out.writeByte(METHOD_MARKER); DataInputOutputUtil.writeINT(out, myOwner); DataInputOutputUtil.writeINT(out, getName()); DataInputOutputUtil.writeINT(out, getParameterCount()); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; JavaCompilerMethodRef methodRef = (JavaCompilerMethodRef)o; if (myOwner != methodRef.myOwner) return false; if (myName != methodRef.myName) return false; if (myParameterCount != methodRef.myParameterCount) return false; return true; }

equals

int () { int result = myName; result = 31 * result + myParameterCount; result = 31 * result + myOwner; return result; }

hashCode

int () { return myName; }

getName

CompilerRef (int newOwner) { return new JavaCompilerFieldRef(newOwner, myName); }

override

CompilerClassHierarchyElementDef () { return new JavaCompilerClassRef(myOwner); }

getOwner

void (DataOutput out) { try { out.writeByte(FIELD_MARKER); DataInputOutputUtil.writeINT(out, myOwner); DataInputOutputUtil.writeINT(out, getName()); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; JavaCompilerFieldRef fieldRef = (JavaCompilerFieldRef)o; if (myOwner != fieldRef.myOwner) return false; if (myName != fieldRef.myName) return false; return true; }

equals

int () { return myName + 31 * myOwner; }

hashCode

CompilerRef (int newOwner) { throw new UnsupportedOperationException(); }

override

int () { return myName; }

getName

void (DataOutput out) { try { out.writeByte(ANONYMOUS_CLASS_MARKER); DataInputOutputUtil.writeINT(out, getName()); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; JavaCompilerAnonymousClassRef ref = (JavaCompilerAnonymousClassRef)o; if (myName != ref.myName) return false; return true; }

equals

int () { return myName; }

hashCode

int () { return myName; }

getName

CompilerRef (int newOwner) { return new JavaCompilerClassRef(newOwner); }

override

void (DataOutput out) { try { out.writeByte(CLASS_MARKER); DataInputOutputUtil.writeINT(out, getName()); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; JavaCompilerClassRef classRef = (JavaCompilerClassRef)o; if (myName != classRef.myName) return false; return true; }

equals

int () { return myName; }

hashCode

int () { return myId; }

getId

CompilerRef (int newOwner) { throw new UnsupportedOperationException(); }

override

void (DataOutput out) { try { out.writeByte(FUN_EXPR_MARKER); DataInputOutputUtil.writeINT(out, getId()); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; JavaCompilerFunExprDef funExprDef = (JavaCompilerFunExprDef)o; return myId == funExprDef.myId; }

equals

int () { return myId; }

hashCode

void (int id, Input d) { for (InvertedIndex<?, ?, Input> index : myIndex.getIndices()) { index.mapInputAndPrepareUpdate(id, d).compute(); } }

writeData

Throwable () { return myIndex.getRebuildRequestCause(); }

getRebuildRequestCause

void (Throwable e) { myIndex.setRebuildRequestCause(e); }

setRebuildCause

void () { myIndex.force(); }

force

void () { myIndex.close(); }

close

void () { myWriter = JavaBackwardReferenceIndexWriter.getInstance(); }

initialize

boolean () { return JavaBackwardReferenceIndexWriter.isEnabled() && JavaBackwardReferenceIndexWriter.getInstance() != null; }

isEnabled

void (CompileContext context, String filePath, Iterable<Map.Entry<? extends JavacRef, Integer>> refs, Collection<? extends JavacDef> defs, Collection<? extends JavacTypeCast> casts, Collection<? extends JavacRef> implicitToString) { BackwardReferenceIndexUtil.registerFile(filePath, refs, defs, casts, implicitToString, myWriter); }

registerFile

int (CompilerRef value) { return value.hashCode(); }

getHashCode

boolean (CompilerRef val1, CompilerRef val2) { return val1.equals(val2); }

isEqual

void (@NotNull DataOutput out, CompilerRef value) { value.save(out); }

save

String () { return JpsBuildBundle.message("builder.name.backward.references.indexer"); }

getPresentableName

void (CompileContext context) { JavaBackwardReferenceIndexWriter.initialize(context); }

buildStarted

void (CompileContext context) { if (JavaBackwardReferenceIndexWriter.getInstance() != null) { final BuildTargetIndex targetIndex = context.getProjectDescriptor().getBuildTargetIndex(); for (JpsModule module : context.getProjectDescriptor().getProject().getModules()) { boolean allAreDummyOrCompiled = true; for (ModuleBasedTarget<?> target : targetIndex.getModuleBasedTargets(module, BuildTargetRegistry.ModuleTargetSelector.ALL)) { if (target instanceof ModuleBuildTarget && !myCompiledTargets.contains(target) && !targetIndex.isDummy(target)) { allAreDummyOrCompiled = false; } } if (allAreDummyOrCompiled) { context.processMessage(new CustomBuilderMessage(BUILDER_ID, MESSAGE_TYPE, module.getName())); } } myCompiledTargets.clear(); } JavaBackwardReferenceIndexWriter.closeIfNeeded(false); }

buildFinished

List<String> () { return Collections.emptyList(); }

getCompilableFileExtensions

String (@NotNull String path) { return SystemInfo.isFileSystemCaseSensitive ? path : StringUtil.toLowerCase(path); }

convertToCaseAwarePath

void () { synchronized (myNameEnumerator) { if (!myNameEnumerator.isClosed()) { myNameEnumerator.force(); } } synchronized (myFilePathEnumerator) { if (!myFilePathEnumerator.isClosed()) { myFilePathEnumerator.force(); } } for (InvertedIndex<?, ?, Input> index : myIndices.values()) { try { index.flush(); } catch (StorageException e) { LOG.error(e); } } }

force

NameEnumerator () { return myNameEnumerator; }

getByteSeqEum

PersistentStringEnumerator () { return myFilePathEnumerator; }

getFilePathEnumerator

void () { myLowMemoryWatcher.stop(); final CommonProcessors.FindFirstProcessor<Exception> exceptionProc = new CommonProcessors.FindFirstProcessor<Exception>() { @Override public boolean process(Exception e) { LOG.error(e); return super.process(e); } }; close(myFilePathEnumerator, exceptionProc); close(myNameEnumerator, exceptionProc); for (Iterator<Map.Entry<IndexId<?, ?>, InvertedIndex<?, ?, Input>>> iterator = myIndices.entrySet().iterator(); iterator.hasNext(); ) { Map.Entry<IndexId<?, ?>, InvertedIndex<?, ?, Input>> index = iterator.next(); close(index.getValue(), exceptionProc); iterator.remove(); } final Exception exception = exceptionProc.getFoundValue(); if (exception != null) { removeIndexFiles(myBuildDir, exception); if (myRebuildRequestCause == null) { throw new RuntimeException(exception); } return; } if (myRebuildRequestCause != null) { removeIndexFiles(myBuildDir, myRebuildRequestCause); } }

close

boolean (Exception e) { LOG.error(e); return super.process(e); }

process

void (File buildDir) { removeIndexFiles(buildDir, null); }

removeIndexFiles

void (File buildDir, Throwable cause) { final File indexDir = getIndexDir(buildDir); if (indexDir.exists()) { try { FileUtilRt.deleteRecursively(indexDir.toPath()); LOG.info("backward reference index deleted", cause != null ? cause : new Exception()); } catch (Throwable e) { LOG.info("failed to delete backward reference index", e); } } }

removeIndexFiles

File (@NotNull File buildDir) { return new File(buildDir, "backward-refs"); }

getIndexDir

boolean (@NotNull File buildDir) { return getIndexDir(buildDir).exists(); }

exists

boolean (@NotNull File buildDir, int expectedVersion) { Path versionFile = getIndexDir(buildDir).toPath().resolve(VERSION_FILE); try (DataInputStream is = new DataInputStream(Files.newInputStream(versionFile))) { int currentIndexVersion = is.readInt(); boolean isDiffer = currentIndexVersion != expectedVersion; if (isDiffer) { LOG.info("backward reference index version differ, expected = " + expectedVersion + ", current = " + currentIndexVersion); } return isDiffer; } catch (NoSuchFileException ignore) { LOG.info("backward reference index version doesn't exist"); } catch (IOException e) { LOG.info("backward reference index version differ due to: " + e.getClass()); } return true; }

versionDiffers

void (@NotNull File buildDir, int version) { File versionFile = new File(getIndexDir(buildDir), VERSION_FILE); FileUtil.createIfDoesntExist(versionFile); try (DataOutputStream os = new DataOutputStream(new FileOutputStream(versionFile))) { os.writeInt(version); } catch (IOException ex) { LOG.error(ex); throw new BuildDataCorruptedException(ex); } }

saveVersion

Throwable () { return myRebuildRequestCause; }

getRebuildRequestCause

File () { return myIndicesDir; }

getIndicesDir

void (Throwable e) { myRebuildRequestCause = e; LOG.error(e); }

setRebuildRequestCause

void (InvertedIndex<?, ?, ?> index, CommonProcessors.FindFirstProcessor<? super Exception> exceptionProcessor) { try { index.dispose(); } catch (Exception e) { exceptionProcessor.process(e); } }

close

void (Closeable closeable, Processor<? super Exception> exceptionProcessor) { //noinspection SynchronizationOnLocalVariableOrMethodParameter synchronized (closeable) { try { closeable.close(); } catch (IOException e) { exceptionProcessor.process(new BuildDataCorruptedException(e)); } catch (Exception e) { exceptionProcessor.process(e); } } }

close

void () { }

checkCanceled

void (@NotNull Throwable e) { setRebuildRequestCause(e); }

requestRebuild

KeyDescriptor<CompilerRef> () { return CompilerRefDescriptor.INSTANCE; }

getKeyDescriptor

DataExternalizer<Void> () { return VoidDataExternalizer.INSTANCE; }

getValueExternalizer

int () { return VERSION; }

getVersion

KeyDescriptor<CompilerRef> () { return CompilerRefDescriptor.INSTANCE; }

getKeyDescriptor

DataExternalizer<Collection<CompilerRef>> () { return createCompilerRefSeqExternalizer(); }

getValueExternalizer

int () { return VERSION; }

getVersion