Datasets:

Mlxa

/

java_methods

like 0

String (final DependencyContext context) { final StringBuilder buf = new StringBuilder(); buf.append("("); for (TypeRepr.AbstractType t : myArgumentTypes) { buf.append(t.getDescr(context)); } buf.append(")"); buf.append(myType.getDescr(context)); return buf.toString(); }

getDescr

void (final DependencyContext context, final PrintStream stream) { super.toStream(context, stream); stream.print(" Arguments : "); for (TypeRepr.AbstractType t : myArgumentTypes) { stream.print(t.getDescr(context)); stream.print("; "); } stream.println(); final TypeRepr.AbstractType[] es = myExceptions.toArray(TypeRepr.AbstractType.EMPTY_TYPE_ARRAY); Arrays.sort(es, Comparator.comparing(o -> o.getDescr(context))); stream.print(" Exceptions : "); for (final TypeRepr.AbstractType e : es) { stream.print(e.getDescr(context)); stream.print("; "); } stream.println(); }

toStream

Set<Recompile> ( DependencyContext context, MethodRepr method, Difference.Specifier<TypeRepr.ClassType, Difference> annotationsDiff, Difference.Specifier<ParamAnnotation, Difference> paramAnnotationsDiff ) { return RECOMPILE_NONE; }

methodAnnotationsChanged

Set<Recompile> ( NamingContext context, ProtoMethodEntity method, Difference.Specifier<TypeRepr.ClassType, Difference> annotationsDiff, Difference.Specifier<ParamAnnotation, Difference> paramAnnotationsDiff ) { if (method instanceof MethodRepr && context instanceof DependencyContext) { Set<Recompile> result = methodAnnotationsChanged((DependencyContext)context, (MethodRepr)method, annotationsDiff, paramAnnotationsDiff); if (!result.isEmpty()) { return result; } } return RECOMPILE_NONE; }

methodAnnotationsChanged

Set<Recompile> (NamingContext context, FieldRepr field, Difference.Specifier<TypeRepr.ClassType, Difference> annotationsDiff) { return RECOMPILE_NONE; }

fieldAnnotationsChanged

Set<Recompile> (NamingContext context, ProtoFieldEntity field, Difference.Specifier<TypeRepr.ClassType, Difference> annotationsDiff) { if (field instanceof FieldRepr) { Set<Recompile> result = fieldAnnotationsChanged(context, (FieldRepr)field, annotationsDiff); if (!result.isEmpty()) { return result; } } return RECOMPILE_NONE; }

fieldAnnotationsChanged

Set<Recompile> (NamingContext context, ClassRepr aClass, Difference.Specifier<TypeRepr.ClassType, Difference> annotationsDiff) { return RECOMPILE_NONE; }

classAnnotationsChanged

int () { return myDelegate.base(); }

base

boolean () { return myDelegate.no(); }

no

boolean () { return myDelegate.accessRestricted(); }

accessRestricted

boolean () { return myDelegate.accessExpanded(); }

accessExpanded

int () { return myDelegate.addedModifiers(); }

addedModifiers

int () { return myDelegate.removedModifiers(); }

removedModifiers

boolean () { return myDelegate.packageLocalOn(); }

packageLocalOn

boolean () { return myDelegate.hadValue(); }

hadValue

Set<Integer> () { return Collections.unmodifiableSet(myModuleNames); }

getModuleNames

boolean () { return !myModuleNames.isEmpty(); }

isQualified

void (DataOutput out) { super.save(out); RW.save(myModuleNames, INT_EXTERNALIZER, out); }

save

boolean (Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } return name == ((ModulePackageRepr)o).name; }

equals

int () { return 31 * name; }

hashCode

Diff (Proto past) { final Difference.Specifier<Integer, Difference> targetModulesDiff = Difference.make(((ModulePackageRepr)past).myModuleNames, myModuleNames); return new Diff(super.difference(past)) { @Override public Specifier<Integer, Difference> targetModules() { return targetModulesDiff; } @Override public boolean no() { return super.no() && targetModules().unchanged(); } }; }

difference

boolean () { return super.no() && targetModules().unchanged(); }

no

void (DependencyContext context, PrintStream stream) { final StringBuilder sb = new StringBuilder(); sb.append("Module package: ").append(context.getValue(name)); final Set<Integer> moduleNames = myModuleNames; if (!moduleNames.isEmpty()) { final List<String> names = new ArrayList<>(); for (Integer moduleName : moduleNames) { names.add(context.getValue(moduleName)); } names.sort(String::compareToIgnoreCase); sb.append(" to"); for (String s : names) { sb.append(" ").append(s); } } stream.println(sb); }

toStream

DataExternalizer<ModulePackageRepr> (final DependencyContext context) { return new DataExternalizer<ModulePackageRepr>() { @Override public void save(@NotNull DataOutput out, ModulePackageRepr value) { value.save(out); } @Override public ModulePackageRepr read(@NotNull DataInput in) { return new ModulePackageRepr(context, in); } }; }

externalizer

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

save

ModulePackageRepr (@NotNull DataInput in) { return new ModulePackageRepr(context, in); }

read

boolean (final int key) { try { return map.containsMapping(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

containsKey

IntSet (final int key) { final IntSet collection = cache.get(key); return collection == NULL_COLLECTION ? null : collection; }

get

void (int key, IntSet value) { try { cache.invalidate(key); if (value == null || value.isEmpty()) { map.remove(key); } else { map.put(key, value); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

replace

void (final int key, final IntSet values) { try { if (!values.isEmpty()) { cache.invalidate(key); map.appendData(key, getAddAppender(values)); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

put

void (final int key, final int value) { try { cache.invalidate(key); map.appendData(key, getAddAppender(value)); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

put

void (int key, IntSet values) { try { if (!values.isEmpty()) { cache.invalidate(key); map.appendData(key, getRemoveAppender(values)); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

removeAll

void (final int key, final int value) { try { final IntSet collection = cache.get(key); if (collection != NULL_COLLECTION) { if (collection.remove(value)) { cache.invalidate(key); if (collection.isEmpty()) { map.remove(key); } else { map.appendData(key, getRemoveAppender(value)); } } } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

removeFrom

void (final int key) { try { cache.invalidate(key); map.remove(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

remove

void (IntIntMultiMaplet m) { m.forEachEntry((integers, value) -> put(value, integers)); }

putAll

void (IntIntMultiMaplet m) { m.forEachEntry((integers, value) -> replace(value, integers)); }

replaceAll

void () { try { cache.invalidateAll(); map.close(); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

close

void (boolean memoryCachesOnly) { if (memoryCachesOnly) { if (map.isDirty()) { map.dropMemoryCaches(); } } else { map.force(); } }

flush

boolean (final int key) { try { return map.containsMapping(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

containsKey

IntSet (final int key) { final IntSet collection = cache.get(key); return collection == NULL_COLLECTION ? null : collection; }

get

void (int key, IntSet value) { try { cache.invalidate(key); if (value == null || value.isEmpty()) { map.remove(key); } else { map.put(key, value); } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

replace

void (final int key, final IntSet value) { try { cache.invalidate(key); map.appendData(key, new AppendablePersistentMap.ValueDataAppender() { @Override public void append(final @NotNull DataOutput out) throws IOException { IntIterator iterator = value.iterator(); while (iterator.hasNext()) { int value1 = iterator.nextInt(); DataInputOutputUtil.writeINT(out, value1); } } }); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

put

void (final int key, final int value) { try { cache.invalidate(key); map.appendData(key, new AppendablePersistentMap.ValueDataAppender() { @Override public void append(final @NotNull DataOutput out) throws IOException { DataInputOutputUtil.writeINT(out, value); } }); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

put

void (int key, IntSet values) { try { IntSet collection = cache.get(key); if (collection != NULL_COLLECTION) { if (collection.removeAll(values)) { cache.invalidate(key); if (collection.isEmpty()) { map.remove(key); } else { map.put(key, collection); } } } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

removeAll

void (final int key, final int value) { try { final IntSet collection = cache.get(key); if (collection != NULL_COLLECTION) { if (collection.remove(value)) { cache.invalidate(key); if (collection.isEmpty()) { map.remove(key); } else { map.put(key, collection); } } } } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

removeFrom

void (final int key) { try { cache.invalidate(key); map.remove(key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

remove

void (IntIntMultiMaplet m) { m.forEachEntry((integers, value) -> put(value, integers)); }

putAll

void (IntIntMultiMaplet m) { m.forEachEntry((integers, value) -> replace(value, integers)); }

replaceAll

void () { try { cache.invalidateAll(); map.close(); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

close

void (boolean memoryCachesOnly) { if (memoryCachesOnly) { if (map.isDirty()) { map.dropMemoryCaches(); } } else { map.force(); } }

flush

void (ObjIntConsumer<? super IntSet> procedure) { try { map.processKeysWithExistingMapping(key -> { try { procedure.accept(map.get(key), key); } catch (IOException e) { throw new BuildDataCorruptedException(e); } return true; }); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

forEachEntry

int () { return myFileName; }

getFileName

boolean (final UsageRepr.Usage usage) { return myUsages.add(usage); }

addUsage

void (DependencyContext context, PrintStream stream) { super.toStream(context, stream); stream.print(" Filename : "); stream.println(context.getValue(myFileName)); }

toStream

void (final DataOutput out) { try { super.save(out); DataInputOutputUtil.writeINT(out, myFileName); RW.save(myUsages, UsageRepr.externalizer(myContext), out); } catch (IOException e) { throw new BuildDataCorruptedException(e); } }

save

int () { return 31 * myFileName + name; }

hashCode

boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ClassFileRepr classRepr = (ClassFileRepr)o; if (myFileName != classRepr.myFileName) return false; if (name != classRepr.name) return false; return true; }

equals

InternedString (final DependencyContext context, final String val) { return new InternedString() { @Override public DependencyContext getContext() { return context; } @Override public int asInt() { return context.get(val); } @Override public String asString() { return val; } }; }

create

DependencyContext () { return context; }

getContext

int () { return context.get(val); }

asInt

String () { return val; }

asString

InternedString (final DependencyContext context, final int val) { return new InternedString() { @Override public @NotNull DependencyContext getContext() { return context; } @Override public int asInt() { return val; } @Override public String asString() { return getContext().getValue(val); } }; }

create

DependencyContext () { return context; }

getContext

int () { return val; }

asInt

String () { return getContext().getValue(val); }

asString

int (final Entry o) { return o.myString.compareTo(myString); }

compareTo

void (final DependencyContext context, final PrintStream stream) { final OrderProvider op = new OrderProvider(context); forEachEntry((integers, value) -> op.register(value)); final int[] keys = op.get(); for (final int a : keys) { final IntSet b = get(a); if (b == null) { continue; } stream.print(" Key: "); stream.println(context.getValue(a)); stream.println(" Values:"); final List<String> list = new LinkedList<>(); b.forEach(value -> { list.add(context.getValue(value)); }); Collections.sort(list); for (final String l : list) { stream.print(" "); stream.println(l); } stream.println(" End Of Values"); } }

toStream

ArtifactOutputToSourceMapping (File targetDataDir) { throw new UnsupportedOperationException("Unsupported creation type of ArtifactOutputToSourceMapping"); }

createStorage

List<BuildTargetChunk> (@NotNull CompileContext context) { initializeChunks(context); return myTargetChunks; }

getSortedTargetChunks

boolean (@NotNull BuildTarget<?> target) { return target.getTargetType().isFileBased() && myBuildRootIndex.getTargetRoots(target, null).isEmpty(); }

isDummy

void (BuildTarget<?> target, LinkedHashSet<? super BuildTarget<?>> result, CompileContext context) { if (result.add(target)) { for (BuildTarget<?> dep : getDependencies(target,context)) { collectDependenciesRecursively(dep, result, context); } } }

collectDependenciesRecursively

String () { return myTargets.toString(); }

toString

String () { final String name = myTargets.iterator().next().getPresentableName(); final int size = myTargets.size(); return size > 1 ? name + " and " + (size - 1) + " more" : name; }

getPresentableName

BuildTargetChunk (@NotNull BuildTarget<?> target) { return new BuildTargetChunk(Collections.singleton(target)); }

forSingleTarget

BuildTargetChunk (@NotNull ModuleChunk chunk) { return new BuildTargetChunk(chunk.getTargets()); }

forModulesChunk

File () { return myDataStorageRoot; }

getDataStorageRoot

File () { return new File(myDataStorageRoot, "targets"); }

getTargetsDataRoot

File (@NotNull BuildTargetType<?> targetType) { return new File(getTargetsDataRoot(), targetType.getTypeId()); }

getTargetTypeDataRoot

File (@NotNull BuildTarget<?> target) { BuildTargetType<?> targetType = target.getTargetType(); final String targetId = target.getId(); return getTargetDataRoot(targetType, targetId); }

getTargetDataRoot

File (@NotNull BuildTargetType<?> targetType, @NotNull String targetId) { // targetId may diff from another targetId only in case // when used as a file name in case-insensitive file systems, both paths for different targets will point to the same dir return new File(getTargetTypeDataRoot(targetType), PathUtilRt.suggestFileName(targetId + "_" + Integer.toHexString(targetId.hashCode()), true, false)); }

getTargetDataRoot

void (File output, String outputRootPath, String relativePath) { File[] children = output.listFiles(); if (children == null) { myFileGeneratedEvent.add(outputRootPath, relativePath); } else { String prefix = relativePath.isEmpty() || relativePath.equals(".") ? "" : relativePath + "/"; for (File child : children) { addEventsRecursively(child, outputRootPath, prefix + child.getName()); } } }

addEventsRecursively

int () { return myRegisteredSources.size(); }

getNumberOfProcessedSources

void () { if (!myFileGeneratedEvent.getPaths().isEmpty()) { myContext.processMessage(myFileGeneratedEvent); } }

fireFileGeneratedEvent

void (BuildRootDescriptor descriptor) { List<BuildRootDescriptor> list = myRootToDescriptors.get(descriptor.getRootFile()); if (list == null) { list = new SmartList<>(); myRootToDescriptors.put(descriptor.getRootFile(), list); } list.add(descriptor); }

registerDescriptor

boolean (File file, int parentsToCheck, BuildRootDescriptor descriptor) { File current = file; while (parentsToCheck-- > 0) { current = FileUtil.getParentFile(current); if (!isDirectoryAccepted(current, descriptor)) { return false; } } return true; }

isParentDirectoriesAccepted

FileFilter (@NotNull BuildRootDescriptor descriptor) { FileFilter filter = myFileFilters.get(descriptor); if (filter == null) { filter = descriptor.createFileFilter(); myFileFilters.put(descriptor, filter); } return filter; }

getRootFilter

boolean (@NotNull File file, @NotNull BuildRootDescriptor descriptor) { return !myIgnoredFileIndex.isIgnored(file.getName()) && getRootFilter(descriptor).accept(file); }

isFileAccepted

boolean (@NotNull File dir, @NotNull BuildRootDescriptor descriptor) { return !myIgnoredFileIndex.isIgnored(dir.getName()) && !descriptor.getExcludedRoots().contains(dir); }

isDirectoryAccepted

boolean (@NotNull T target, @NotNull File file, @NotNull R root) { hasDirtyFiles.set(true); return false; }

apply

boolean () { Map<BuildTarget<?>, Collection<String>> map = Utils.REMOVED_SOURCES_KEY.get(myContext); return map != null && !map.isEmpty(); }

hasRemovedFiles

Collection<String> (@NotNull T target) { Map<BuildTarget<?>, Collection<String>> map = Utils.REMOVED_SOURCES_KEY.get(myContext); if (map != null) { Collection<String> paths = map.get(target); if (paths != null) { return paths; } } return Collections.emptyList(); }

getRemovedFiles

String () { return FileUtilRt.toSystemIndependentName(myRoot.getAbsolutePath()); }

getRootId

File () { return myRoot; }

getRootFile

boolean () { return myCanUseFileCache; }

canUseFileCache

Iterable<StorageOwner> () { return () -> myStorages.values().iterator(); }

getChildStorages

String () { return JavaCompilers.ECLIPSE_ID; }

getId

String () { return JavaCompilers.ECLIPSE_EMBEDDED_ID; }

getAlternativeId

String () { String version = myVersion; if (version == null) { version = ""; JavaCompiler compiler = findCompiler(); Path file = compiler == null ? null : PathManager.getJarForClass(compiler.getClass()); if (file != null) { String name = file.getFileName().toString(); if (name.startsWith(JAR_FILE_NAME_PREFIX) && name.endsWith(JAR_FILE_NAME_SUFFIX)) { version = " " + name.substring(JAR_FILE_NAME_PREFIX.length(), name.length() - JAR_FILE_NAME_SUFFIX.length()); } } myVersion = version; } return "Eclipse compiler" + version; }

getDescription

List<File> () { File element = findEcjJarFile(); return ContainerUtil.createMaybeSingletonList(element); }

getAdditionalClasspath

List<String> () { return Collections.singletonList("-noExit"); }

getDefaultCompilerOptions