Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
34,000
Boolean (Instruction cur, int destination, LinkedHashSet<Integer> fragmentInsns, boolean wasOutside, HashMap<Instruction, Boolean> visited) { wasOutside = wasOutside || !fragmentInsns.contains(cur.num()); visited.put(cur, null); Iterable<? extends Instruction> instructions = cur.allSuccessors(); boolean pathExists = false; for (Instruction i : instructions) { if (i.num() == destination) return wasOutside; Boolean result; if (visited.containsKey(i)) { result = visited.get(i); } else { result = findPath(i, destination, fragmentInsns, wasOutside, visited); visited.put(i, result); } if (result != null) { if (result.booleanValue()) { visited.put(cur, true); return true; } pathExists = true; } } if (pathExists) { visited.put(cur, false); return false; } else { visited.put(cur, null); return null; } }
findPath
34,001
boolean (Instruction insn) { return insn instanceof ReadWriteVariableInstruction && !((ReadWriteVariableInstruction)insn).isWrite(); }
isReadInsn
34,002
String (ArrayList<Int2ObjectMap<IntSet>> dfaResult, ReachingDefinitionsDfaInstance dfa) { @NonNls final StringBuffer buffer = new StringBuffer(); for (int i = 0; i < dfaResult.size(); i++) { Int2ObjectMap<IntSet> map = dfaResult.get(i); buffer.append("At ").append(i).append(":\n"); for (IntSet v : map.values()) { buffer.append(i).append(" -> "); v.forEach((IntConsumer)i1 -> { buffer.append(i1).append(" "); }); } buffer.append("\n"); } return buffer.toString(); }
dumpDfaResult
34,003
String () { return myName; }
getName
34,004
PsiType () { if (myType instanceof PsiIntersectionType) return ((PsiIntersectionType)myType).getConjuncts()[0]; return myType; }
getType
34,005
Int2ObjectMap<int[]> (@NotNull final List<DefinitionMap> dfaResult, Instruction @NotNull [] flow) { Int2ObjectMap<int[]> result = new Int2ObjectOpenHashMap<>(); for (int i = 0; i < flow.length; i++) { Instruction insn = flow[i]; if (!(insn instanceof ReadWriteVariableInstruction rwInsn)) { continue; } if (rwInsn.isWrite()) { continue; } DefinitionMap definitionMap = dfaResult.get(i); definitionMap = definitionMap == null ? DefinitionMap.NEUTRAL : definitionMap; int varIndex = rwInsn.getDescriptor(); IntSet defs = definitionMap.getDefinitions(varIndex); if (defs == null) { defs = IntSet.of(); } result.put(i, defs.toIntArray()); } return result; }
postprocess
34,006
DefinitionMap (int varIndex, @NotNull Instruction instruction) { if (varIndex == 0) { return this; } Int2ObjectMap<IntSet> newMap = new Int2ObjectOpenHashMap<>(myMap); IntSet defs = new IntArraySet(1); newMap.put(varIndex, defs); defs.add(instruction.num()); return new DefinitionMap(newMap); }
withRegisteredDef
34,007
DefinitionMap (DefinitionMap other) { if (other == this || other == NEUTRAL) { return this; } if (this == NEUTRAL) { return other; } Int2ObjectMap<IntSet> newMap = new Int2ObjectOpenHashMap<>(myMap); List<Integer> toRemove = new SmartList<>(); for (int key : myMap.keySet()) { if (!other.myMap.containsKey(key)) { toRemove.add(key); } } for (int key : toRemove) { newMap.remove(key); } for (Int2ObjectMap.Entry<IntSet> entry : other.myMap.int2ObjectEntrySet()) { int varIndex = entry.getIntKey(); IntSet otherVarDefs = entry.getValue(); IntSet myDefs = newMap.get(varIndex); if (myDefs != null) { IntSet newDefs = new IntArraySet(myDefs); newDefs.addAll(otherVarDefs); newMap.put(varIndex, newDefs); } } return new DefinitionMap(newMap); }
withMerged
34,008
void (Consumer<IntSet> procedure) { myMap.values().forEach(procedure); }
forEachValue
34,009
boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; DefinitionMap map = (DefinitionMap)o; return Objects.equals(myMap, map.myMap); }
equals
34,010
int () { return Objects.hash(myMap); }
hashCode
34,011
String () { return myMap.toString(); }
toString
34,012
DefinitionMap (@NotNull DefinitionMap m, @NotNull Instruction instruction) { if (instruction instanceof ReadWriteVariableInstruction varInsn) { final int descriptor = varInsn.getDescriptor(); if (varInsn.isWrite()) { return m.withRegisteredDef(descriptor, instruction); } else { return m; } } else { return m; } }
fun
34,013
String () { return StringRef.toString(myNameRef); }
getName
34,014
String () { return myTypeText; }
getTypeText
34,015
GrTypeElement () { String typeText = getTypeText(); if (typeText == null) return null; GrTypeElement typeElement = dereference(myTypeElement); if (typeElement == null) { typeElement = GroovyPsiElementFactory.getInstance(getProject()).createTypeElement(typeText, getPsi()); myTypeElement = new SoftReference<>(typeElement); } return typeElement; }
getTypeElement
34,016
String () { return StringRef.toString(myPackageName); }
getPackageName
34,017
String () { return myFqn; }
getFqn
34,018
String () { return myAliasName; }
getAliasName
34,019
boolean () { return (myFlags & STATIC_MASK) != 0; }
isStatic
34,020
boolean () { return (myFlags & ON_DEMAND_MASK) != 0; }
isOnDemand
34,021
byte () { return myFlags; }
getFlags
34,022
byte (boolean isStatic, boolean isOnDemand) { return (byte)((isStatic ? 1 : 0) * STATIC_MASK + (isOnDemand ? 1 : 0) * ON_DEMAND_MASK); }
buildFlags
34,023
int () { return myFlags; }
getModifiersFlags
34,024
GrAnnotation () { GrAnnotation annotation = dereference(myPsiRef); if (annotation != null) { return annotation; } try { annotation = GroovyPsiElementFactory.getInstance(getProject()).createAnnotationFromText(myText, getPsi()); myPsiRef = new SoftReference<>(annotation); return annotation; } catch (IncorrectOperationException e) { LOG.error("Bad annotation in repository!", e); return null; } }
getPsiElement
34,025
String () { return myText; }
getText
34,026
int () { return myFlags; }
getFlags
34,027
int (boolean hasInitializer, boolean isVarArgs) { return (hasInitializer ? 2 : 0) + (isVarArgs ? 1 : 0); }
encodeFlags
34,028
boolean (int flags) { return BitUtil.isSet(flags, 2); }
hasInitializer
34,029
boolean (int flags) { return BitUtil.isSet(flags, 1); }
isVarRags
34,030
String () { return myBaseClassName; }
getBaseClassName
34,031
GrCodeReferenceElement () { String baseClassName = getBaseClassName(); if (baseClassName == null) return null; GrCodeReferenceElement reference = dereference(myStubBaseReference); if (reference == null) { reference = GroovyPsiElementFactory.getInstance(getProject()).createCodeReference(baseClassName, getPsi()); myStubBaseReference = new SoftReference<>(reference); } return reference; }
getBaseClassReference
34,032
String () { return StringRef.toString(myName); }
getName
34,033
String[] () { return myAnnotations; }
getAnnotations
34,034
String () { return StringRef.toString(myQualifiedName); }
getQualifiedName
34,035
boolean () { return (myFlags & ANNOTATION) != 0; }
isAnnotationType
34,036
boolean () { return (myFlags & ANONYMOUS) != 0; }
isAnonymous
34,037
boolean () { return (myFlags & INTERFACE) != 0; }
isInterface
34,038
byte () { return myFlags; }
getFlags
34,039
boolean () { return (myFlags & DEPRECATED_BY_DOC) != 0; }
isDeprecatedByDoc
34,040
byte (GrTypeDefinition typeDefinition) { byte flags = 0; if (typeDefinition.isAnonymous()) { flags |= ANONYMOUS; assert typeDefinition instanceof GrAnonymousClassDefinition; } if (typeDefinition.isAnnotationType()) flags |= ANNOTATION; if (typeDefinition.isInterface()) flags |= INTERFACE; if (PsiImplUtil.isDeprecatedByDocTag(typeDefinition)) flags |= DEPRECATED_BY_DOC; return flags; }
buildFlags
34,041
IStubFileElementType () { return GroovyParserDefinition.GROOVY_FILE; }
getType
34,042
StringRef () { return myName; }
getName
34,043
boolean () { return isScript; }
isScript
34,044
String[] () { return myRefNames; }
getBaseClasses
34,045
String () { return myTypeString; }
getTypeString
34,046
GrTypeElement () { String typeString = getTypeString(); if (typeString == null) return null; GrTypeElement typeElement = dereference(myTypeElement); if (typeElement == null) { typeElement = GroovyPsiElementFactory.getInstance(getProject()).createTypeElement(typeString, getPsi()); myTypeElement = new SoftReference<>(typeElement); } return typeElement; }
getTypeElement
34,047
boolean () { return (myFlags & IS_PROPERTY) != 0; }
isProperty
34,048
boolean () { return (myFlags & IS_DEPRECATED_BY_DOC_TAG) != 0; }
isDeprecatedByDocTag
34,049
byte () { return myFlags; }
getFlags
34,050
byte (GrField field) { byte f = 0; if (field instanceof GrEnumConstant) { f |= IS_ENUM_CONSTANT; } if (field.isProperty()) { f |= IS_PROPERTY; } if (PsiImplUtil.isDeprecatedByDocTag(field)) { f |= IS_DEPRECATED_BY_DOC_TAG; } return f; }
buildFlags
34,051
boolean (byte flags) { return (flags & IS_ENUM_CONSTANT) != 0; }
isEnumConstant
34,052
String () { return StringRef.toString(myName); }
getName
34,053
String[] () { return myAnnotations; }
getAnnotations
34,054
String () { return myTypeText; }
getTypeText
34,055
boolean () { return (myFlags & IS_DEPRECATED_BY_DOC_TAG) != 0; }
isDeprecatedByDoc
34,056
boolean () { return (myFlags & HAS_BLOCK) != 0; }
hasBlock
34,057
boolean () { return (myFlags & HAS_COMMENT) != 0; }
hasComment
34,058
byte (GrMethod method) { byte f = 0; if (PsiImplUtil.isDeprecatedByDocTag(method)) f |= IS_DEPRECATED_BY_DOC_TAG; if (method.hasBlock()) f |= HAS_BLOCK; if (method.getDocComment() != null) f |= HAS_COMMENT; return f; }
buildFlags
34,059
byte () { return myFlags; }
getFlags
34,060
String () { return StringRef.toString(myName); }
getName
34,061
String (@Nullable GrTypeElement typeElement) { return typeElement == null ? null : typeElement.getText(); }
getTypeText
34,062
String (@NotNull GrReferenceElement element) { final String referenceName = element.getReferenceName(); if (referenceName == null) return null; // Foo -> java.util.List final String mappedFqn = getAliasMapping(element.getContainingFile()).get(referenceName); final String fullText = element.getText(); // alias: Foo<String> -> java.util.List<String> // unqualified ref: List<String> -> List<String> // qualified ref: java.util.List<String> -> java.util.List<String> return mappedFqn == null || element.isQualified() ? fullText : fullText.replace(referenceName, mappedFqn); }
getReferenceName
34,063
String (@NotNull GrTypeDefinition psi) { if (!(psi instanceof GrAnonymousClassDefinition)) return null; return getReferenceName(((GrAnonymousClassDefinition)psi).getBaseClassReferenceGroovy()); }
getBaseClassName
34,064
String[] (PsiModifierListOwner psi) { List<String> annoNames = new ArrayList<>(); final PsiModifierList modifierList = psi.getModifierList(); if (modifierList instanceof GrModifierList) { for (GrAnnotation annotation : ((GrModifierList)modifierList).getRawAnnotations()) { final String name = annotation.getShortName(); if (StringUtil.isNotEmpty(name)) { annoNames.add(name); } } } return ArrayUtilRt.toStringArray(annoNames); }
getAnnotationNames
34,065
boolean (StubElement<?> stub) { StubElement<?> modifierOwner = stub instanceof GrMethodStub ? stub : stub.getParentStub(); GrModifierListStub type = modifierOwner.findChildStubByType(GroovyStubElementTypes.MODIFIER_LIST); if (type == null) { return false; } int mask = type.getModifiersFlags(); if (hasMaskModifier(mask, PsiModifier.PRIVATE)) { return false; } if (hasMaskModifier(mask, PsiModifier.STATIC)) { return true; } StubElement parent = modifierOwner.getParentStub(); StubElement classStub = parent == null ? null : parent.getParentStub(); if (classStub instanceof GrTypeDefinitionStub && (((GrTypeDefinitionStub)classStub).isAnnotationType() || ((GrTypeDefinitionStub)classStub).isInterface())) { return true; } return false; }
isGroovyStaticMemberStub
34,066
String (@Nullable String text) { if (text == null) { return ""; } int i = text.length(); while (i - 2 >= 0 && text.charAt(i - 2) == '[' && text.charAt(i - 1) == ']') { i -= 2; } return PsiNameHelper.getShortClassName(text.substring(0, i)) + text.substring(i); }
getShortTypeText
34,067
String (final GrFileStub stub) { for (StubElement child : stub.getChildrenStubs()) { if (child instanceof GrPackageDefinitionStub) { return ((GrPackageDefinitionStub)child).getPackageName(); } } return null; }
getPackageName
34,068
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,069
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,070
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,071
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION + 1; }
getVersion
34,072
Collection<PsiClass> (@NotNull String name, @NotNull Project project, @NotNull GlobalSearchScope scope) { return StubIndex.getElements(getKey(), name, project, scope, PsiClass.class); }
get
34,073
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,074
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,075
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,076
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,077
int () { return super.getVersion() + GrStubUtils.GR_STUB_VERSION; }
getVersion
34,078
GrReferenceListStub (@NotNull T psi, StubElement<?> parentStub) { List<String> refNames = new ArrayList<>(); for (GrCodeReferenceElement element : psi.getReferenceElementsGroovy()) { final String name = GrStubUtils.getReferenceName(element); if (StringUtil.isNotEmpty(name)) { refNames.add(name); } } return new GrReferenceListStub(parentStub, this, ArrayUtilRt.toStringArray(refNames)); }
createStub
34,079
void (@NotNull GrReferenceListStub stub, @NotNull IndexSink sink) { for (String name : stub.getBaseClasses()) { if (name != null) { sink.occurrence(GrDirectInheritorsIndex.KEY, PsiNameHelper.getShortClassName(name)); } } }
indexStub
34,080
T (@NotNull GrReferenceListStub stub) { throw new AssertionError(); }
createPsi
34,081
boolean () { return true; }
isLeftBound
34,082
GrMethodStub (@NotNull GrMethod psi, StubElement parentStub) { Set<String> namedParameters = psi.getNamedParameters().keySet(); return new GrMethodStub(parentStub, StringRef.fromString(psi.getName()), GrStubUtils.getAnnotationNames(psi), ArrayUtilRt.toStringArray(namedParameters), this, GrStubUtils.getTypeText(psi.getReturnTypeElementGroovy()), GrMethodStub.buildFlags(psi)); }
createStub
34,083
void (@NotNull GrMethodStub stub, @NotNull IndexSink sink) { String name = stub.getName(); sink.occurrence(GrMethodNameIndex.KEY, name); if (GrStubUtils.isGroovyStaticMemberStub(stub)) { sink.occurrence(JavaStubIndexKeys.JVM_STATIC_MEMBERS_NAMES, name); sink.occurrence(JavaStubIndexKeys.JVM_STATIC_MEMBERS_TYPES, GrStubUtils.getShortTypeText(stub.getTypeText())); } for (String annName : stub.getAnnotations()) { if (annName != null) { sink.occurrence(GrAnnotatedMemberIndex.KEY, annName); } } }
indexStub
34,084
GrMethod (@NotNull GrMethodStub stub) { return new GrMethodImpl(stub); }
createPsi
34,085
GrTypeDefinitionBody (@NotNull EmptyStub stub) { return new GrTypeDefinitionBodyBase.GrClassBody(stub); }
createPsi
34,086
GrMethod (@NotNull GrMethodStub stub) { return new GrConstructorImpl(stub); }
createPsi
34,087
GrEnumConstantInitializer (@NotNull GrTypeDefinitionStub stub) { return new GrEnumConstantInitializerImpl(stub); }
createPsi
34,088
GrTypeDefinitionStub (@NotNull GrEnumConstantInitializer psi, StubElement<?> parentStub) { return doCreateStub(this, psi, parentStub); }
createStub
34,089
GrClassDefinition (@NotNull GrTypeDefinitionStub stub) { return new GrClassDefinitionImpl(stub); }
createPsi
34,090
GrTypeDefinitionStub (@NotNull GrClassDefinition psi, StubElement<?> parentStub) { return doCreateStub(this, psi, parentStub); }
createStub
34,091
GrAnnotationNameValuePair (@NotNull GrNameValuePairStub stub) { return new GrAnnotationNameValuePairImpl(stub); }
createPsi
34,092
GrNameValuePairStub (@NotNull GrAnnotationNameValuePair psi, StubElement parentStub) { String name = psi.getName(); GrAnnotationMemberValue value = psi.getValue(); return new GrNameValuePairStub(parentStub, name, value == null ? null : value.getText()); }
createStub
34,093
GrPermitsClause (@NotNull GrReferenceListStub stub) { return new GrPermitsClauseImpl(stub); }
createPsi
34,094
GrPackageDefinition (@NotNull GrPackageDefinitionStub stub) { return new GrPackageDefinitionImpl(stub); }
createPsi
34,095
GrPackageDefinitionStub (@NotNull GrPackageDefinition psi, StubElement parentStub) { return new GrPackageDefinitionStub(parentStub, GroovyStubElementTypes.PACKAGE_DEFINITION, StringRef.fromString(psi.getPackageName())); }
createStub
34,096
GrField (@NotNull GrFieldStub stub) { return new GrFieldImpl(stub); }
createPsi
34,097
GrFieldStub (@NotNull GrField psi, StubElement parentStub) { String[] annNames = GrStubUtils.getAnnotationNames(psi); Set<String> namedParameters = Collections.emptySet(); if (psi instanceof GrFieldImpl){ namedParameters = psi.getNamedParameters().keySet(); } return new GrFieldStub(parentStub, StringRef.fromString(psi.getName()), annNames, ArrayUtilRt.toStringArray(namedParameters), GroovyStubElementTypes.FIELD, GrFieldStub.buildFlags(psi), GrStubUtils.getTypeText(psi.getTypeElementGroovy())); }
createStub
34,098
void (@NotNull GrFieldStub stub, @NotNull IndexSink sink) { indexFieldStub(stub, sink); }
indexStub
34,099
void (GrFieldStub stub, IndexSink sink) { String name = stub.getName(); sink.occurrence(GrFieldNameIndex.KEY, name); if (GrStubUtils.isGroovyStaticMemberStub(stub)) { sink.occurrence(JavaStubIndexKeys.JVM_STATIC_MEMBERS_NAMES, name); sink.occurrence(JavaStubIndexKeys.JVM_STATIC_MEMBERS_TYPES, GrStubUtils.getShortTypeText(stub.getTypeText())); } for (String annName : stub.getAnnotations()) { if (annName != null) { sink.occurrence(GrAnnotatedMemberIndex.KEY, annName); } } }
indexFieldStub