Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
33,100 | Collection<PsiClassType> () { return implementsTypes; } | getImplementsTypes |
33,101 | void (@NotNull Members other) { methods.addAll(other.getMethods()); fields.addAll(other.getFields()); classes.addAll(other.getClasses()); implementsTypes.addAll(other.getImplementsTypes()); } | addFrom |
33,102 | void (@NotNull TransformationContext context) { GrTypeDefinition clazz = context.getCodeClass(); if (!hasGeneratedImplementations(clazz)) return; final LightMethodBuilder write = new LightMethodBuilder(clazz.getManager(), "writeExternal"); write.addParameter("out", ObjectOutput.class.getName()); write.addException(IOEx... | applyTransformation |
33,103 | boolean (GrTypeDefinition clazz) { return PsiImplUtil.getAnnotation(clazz, GroovyCommonClassNames.GROOVY_TRANSFORM_AUTO_EXTERNALIZE) != null; } | hasGeneratedImplementations |
33,104 | void (@NotNull TransformationContext context) { GrTypeDefinition psiClass = context.getCodeClass(); if (psiClass.isAnonymous() || psiClass.isInterface() || psiClass.isEnum()) { return; } if (!hasInheritConstructorsAnnotation(psiClass)) return; final PsiClass hierarchyView = context.getHierarchyView(); final PsiClass su... | applyTransformation |
33,105 | boolean (PsiClass psiClass) { final PsiModifierList modifierList = psiClass.getModifierList(); return modifierList != null && modifierList.hasAnnotation(GroovyCommonClassNames.GROOVY_TRANSFORM_INHERIT_CONSTRUCTORS); } | hasInheritConstructorsAnnotation |
33,106 | PsiMethod () { return myPrototype; } | getPrototype |
33,107 | String () { PsiClass aClass = myPrototype.getContainingClass(); if (aClass != null && aClass.getName() != null) { return "delegates to " + aClass.getName(); } return null; } | getOriginInfo |
33,108 | PsiElement () { return getContainingClass(); } | getParent |
33,109 | PsiClass () { //noinspection ConstantConditions return super.getContainingClass(); } | getContainingClass |
33,110 | PsiFile () { return getContainingClass().getContainingFile(); } | getContainingFile |
33,111 | boolean (@Nullable PsiAnnotation annotation, @NotNull String strategy) { if (annotation == null) return false; PsiClass aClass = GrAnnotationUtil.inferClassAttribute(annotation, STRATEGY_ATTRIBUTE); if (aClass == null) return false; return StringUtil.getQualifiedName(BUILDER_PACKAGE, strategy).equals(aClass.getQualifie... | isApplicable |
33,112 | PsiField[] (@NotNull TransformationContext context, boolean includeSuper) { return filterFields(includeSuper ? context.getAllFields(false) : context.getFields(), context); } | getFields |
33,113 | PsiField[] (@NotNull GrTypeDefinition clazz, boolean includeSuper, @NotNull TransformationContext context) { return filterFields(includeSuper ? asList(GrClassImplUtil.getAllFields(clazz, false)) : asList(clazz.getFields()), context); } | getFields |
33,114 | PsiField[] (Collection<? extends PsiField> collectedFields, @NotNull TransformationContext context) { return collectedFields.stream() .filter(field -> { PsiModifierList modifierList = field.getModifierList(); if (modifierList instanceof GrModifierList) { return !context.hasModifierProperty((GrModifierList)modifierList,... | filterFields |
33,115 | boolean (@NotNull PsiAnnotation annotation) { return PsiUtil.getAnnoAttributeValue(annotation, "includeSuperProperties", false); } | isIncludeSuperProperties |
33,116 | void (@NotNull TransformationContext context) { GrTypeDefinition typeDefinition = context.getCodeClass(); final PsiAnnotation annotation = PsiImplUtil.getAnnotation(typeDefinition, BUILDER_FQN); if (!isApplicable(annotation, SIMPLE_STRATEGY_NAME)) return; if (isIncludeSuperProperties(annotation)) return; for (GrField f... | applyTransformation |
33,117 | LightMethodBuilder (@NotNull PsiClass builderClass, @NotNull GrVariable field, @NotNull PsiAnnotation annotation) { final String name = field.getName(); final LightMethodBuilder fieldSetter = new LightMethodBuilder(builderClass.getManager(), getFieldMethodName(annotation, name)); fieldSetter.addModifier(PsiModifier.PUB... | createFieldSetter |
33,118 | String (@NotNull PsiAnnotation annotation, @NotNull String fieldName) { final String prefix = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "prefix"); return prefix == null ? "set" + StringUtil.capitalize(fieldName) : prefix.isEmpty() ? fieldName : prefix + StringUtil.capitalize(fieldName); } | getFieldMethodName |
33,119 | void (@NotNull TransformationContext context) { PsiAnnotation annotation = PsiImplUtil.getAnnotation(context.getCodeClass(), BUILDER_FQN); if (!isApplicable(annotation, EXTERNAL_STRATEGY_NAME)) return; final PsiClass constructedClass = GrAnnotationUtil.inferClassAttribute(annotation, "forClass"); if (constructedClass =... | applyTransformation |
33,120 | LightMethodBuilder (@NotNull TransformationContext context, @NotNull PsiMethod setter, @NotNull PsiAnnotation annotation) { PsiClass builderClass = context.getCodeClass(); final String name = PropertyUtilBase.getPropertyNameBySetter(setter); final PsiType type = PropertyUtilBase.getPropertyType(setter); if (type == nul... | createFieldSetter |
33,121 | void (@NotNull TransformationContext context) { new InitializerBuilderStrategyHandler(context).doProcess(); } | applyTransformation |
33,122 | void () { processTypeDefinition(); processConstructors(); } | doProcess |
33,123 | void () { final PsiAnnotation builderAnno = PsiImplUtil.getAnnotation(myContainingClass, BUILDER_FQN); if (!isApplicable(builderAnno, INITIALIZER_STRATEGY_NAME)) return; boolean includeSuper = isIncludeSuperProperties(builderAnno); final PsiClass builderClass = createBuilderClass(builderAnno, getFields(myContext, inclu... | processTypeDefinition |
33,124 | LightPsiClassBuilder (@NotNull final PsiAnnotation annotation, PsiVariable @NotNull [] setters) { final LightPsiClassBuilder builderClass = new BuilderHelperLightPsiClass( myContainingClass, getBuilderClassName(annotation, myContainingClass) ); for (int i = 0; i < setters.length; i++) { builderClass.getTypeParameterLis... | createBuilderClass |
33,125 | LightMethodBuilder (@NotNull LightPsiClassBuilder builderClass, @NotNull PsiVariable field, @NotNull PsiAnnotation annotation, int currentField) { final String name = Objects.requireNonNull(field.getName()); final LightMethodBuilder fieldSetter = new LightMethodBuilder(builderClass.getManager(), getFieldMethodName(anno... | createFieldSetter |
33,126 | LightMethodBuilder (@NotNull PsiAnnotation annotation, @NotNull PsiClass builderClass) { LightMethodBuilder buildMethod = new LightMethodBuilder(annotation.getManager(), builderClass.getLanguage(), getBuildMethodName(annotation)); buildMethod.addModifier(PsiModifier.STATIC); buildMethod.setContainingClass(builderClass)... | createBuildMethod |
33,127 | LightMethodBuilder (@NotNull PsiClass builderClass, @NotNull PsiAnnotation annotation) { final LightMethodBuilder builderMethod = new LightMethodBuilder(myContext.getManager(), getBuilderMethodName(annotation)); builderMethod.addModifier(PsiModifier.STATIC); builderMethod.setOriginInfo(ORIGIN_INFO); builderMethod.setNa... | createBuilderMethod |
33,128 | LightMethodBuilder (@NotNull PsiClass constructedClass, @NotNull PsiClass builderClass, @NotNull PsiAnnotation annotation) { final LightMethodBuilder constructor = new LightMethodBuilder(constructedClass, constructedClass.getLanguage()).addParameter( "builder", createAllSetUnsetType(builderClass, true) ).setConstructor... | createBuilderConstructor |
33,129 | void () { for (GrMethod method : myContainingClass.getCodeMethods()) { final PsiAnnotation annotation = PsiImplUtil.getAnnotation(method, BUILDER_FQN); if (!isApplicable(annotation, INITIALIZER_STRATEGY_NAME)) return; if (method.isConstructor()) { processConstructor(method, annotation); } } } | processConstructors |
33,130 | void (@NotNull GrMethod method, @NotNull PsiAnnotation annotation) { PsiClass builderClass = createBuilderClass(annotation, method.getParameters()); myContext.addMethod(createBuilderMethod(builderClass, annotation)); myContext.addMethod(createBuilderConstructor(myContainingClass, builderClass, annotation)); myContext.a... | processConstructor |
33,131 | String (@NotNull PsiAnnotation annotation) { final String builderMethodName = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "builderMethodName"); return StringUtil.isEmpty(builderMethodName) ? "createInitializer" : builderMethodName; } | getBuilderMethodName |
33,132 | String (@NotNull PsiAnnotation annotation) { final String builderMethodName = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "buildMethodName"); return StringUtil.isEmpty(builderMethodName) ? "create" : builderMethodName; } | getBuildMethodName |
33,133 | PsiType (@NotNull PsiClass builderClass, boolean setUnset) { final PsiClassType type = myElementFactory.createTypeByFQClassName( setUnset ? SET_FQN : UNSET_FQN, builderClass.getResolveScope() ); final PsiType[] mappings = PsiType.createArray(builderClass.getTypeParameters().length); Arrays.fill(mappings, type); return ... | createAllSetUnsetType |
33,134 | void (@NotNull TransformationContext context) { new DefaultBuilderStrategyHandler(context).doProcess(); } | applyTransformation |
33,135 | void () { processTypeDefinition(); processMethods(); } | doProcess |
33,136 | void () { final PsiAnnotation builderAnno = PsiImplUtil.getAnnotation(myContainingClass, BUILDER_FQN); if (!isApplicable(builderAnno, DEFAULT_STRATEGY_NAME)) return; boolean includeSuper = isIncludeSuperProperties(builderAnno); final PsiClass builderClass = createBuilderClass(builderAnno, getFields(myContext, includeSu... | processTypeDefinition |
33,137 | LightPsiClassBuilder (@NotNull final PsiAnnotation annotation, PsiVariable @NotNull [] setters) { return createBuilderClass(annotation, setters, null); } | createBuilderClass |
33,138 | LightPsiClassBuilder (@NotNull final PsiAnnotation annotation, PsiVariable @NotNull [] setters, @Nullable PsiType builtType) { final LightPsiClassBuilder builderClass = new BuilderHelperLightPsiClass( myContainingClass, getBuilderClassName(annotation, myContainingClass) ); for (PsiVariable field : setters) { LightMetho... | createBuilderClass |
33,139 | LightMethodBuilder (@NotNull PsiClass builderClass, @NotNull PsiAnnotation annotation) { final LightMethodBuilder builderMethod = new LightMethodBuilder(myContext.getManager(), getBuilderMethodName(annotation)); builderMethod.addModifier(PsiModifier.STATIC); builderMethod.setOriginInfo(ORIGIN_INFO); builderMethod.setNa... | createBuilderMethod |
33,140 | void () { for (GrMethod method : myContext.getCodeClass().getCodeMethods()) { processMethod(method); } } | processMethods |
33,141 | void (@NotNull GrMethod method) { final PsiAnnotation annotation = PsiImplUtil.getAnnotation(method, BUILDER_FQN); if (!isApplicable(annotation, DEFAULT_STRATEGY_NAME)) return; if (method.isConstructor()) { processConstructor(method, annotation); } else if (method.hasModifierProperty(PsiModifier.STATIC)) { processFacto... | processMethod |
33,142 | void (@NotNull GrMethod method, PsiAnnotation annotation) { PsiClass builderClass = createBuilderClass(annotation, method.getParameters()); myContext.addMethod(createBuilderMethod(builderClass, annotation)); myContext.addInnerClass(builderClass); } | processConstructor |
33,143 | void (@NotNull GrMethod method, PsiAnnotation annotation) { PsiClass builderClass = createBuilderClass(annotation, method.getParameters(), method.getReturnType()); myContext.addMethod(createBuilderMethod(builderClass, annotation)); myContext.addInnerClass(builderClass); } | processFactoryMethod |
33,144 | String (@NotNull PsiAnnotation annotation) { final String builderMethodName = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "builderMethodName"); return StringUtil.isEmpty(builderMethodName) ? "builder" : builderMethodName; } | getBuilderMethodName |
33,145 | String (@NotNull PsiAnnotation annotation, @NotNull GrTypeDefinition clazz) { final String builderClassName = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "builderClassName"); return builderClassName == null ? clazz.getName() + "Builder" : builderClassName; } | getBuilderClassName |
33,146 | LightMethodBuilder (@NotNull PsiAnnotation annotation, @NotNull PsiType builtType) { final LightMethodBuilder buildMethod = new LightMethodBuilder(annotation.getManager(), getBuildMethodName(annotation)); buildMethod.setOriginInfo(ORIGIN_INFO); buildMethod.setMethodReturnType(builtType); return buildMethod; } | createBuildMethod |
33,147 | LightMethodBuilder (@NotNull PsiClass builderClass, @NotNull PsiVariable field, @NotNull PsiAnnotation annotation, @NotNull TransformationContext context) { String name = Objects.requireNonNull(field.getName()); return createFieldSetter(builderClass, name, field.getType(), annotation, field, context); } | createFieldSetter |
33,148 | LightMethodBuilder (@NotNull PsiClass builderClass, @NotNull String name, @NotNull PsiType type, @NotNull PsiAnnotation annotation, @NotNull PsiElement navigationElement, @NotNull TransformationContext context) { final LightMethodBuilder fieldSetter = new LightMethodBuilder(builderClass.getManager(), getFieldMethodName... | createFieldSetter |
33,149 | String (@NotNull PsiAnnotation annotation, @NotNull String fieldName) { final String prefix = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "prefix"); return StringUtil.isEmpty(prefix) ? fieldName : String.format("%s%s", prefix, StringUtil.capitalize(fieldName)); } | getFieldMethodName |
33,150 | String (@NotNull PsiAnnotation annotation) { final String buildMethodName = AnnotationUtil.getDeclaredStringAttributeValue(annotation, "buildMethodName"); return StringUtil.isEmpty(buildMethodName) ? "build" : buildMethodName; } | getBuildMethodName |
33,151 | Applicability (@NotNull Collection<Applicability> applicabilities) { return applicabilities.isEmpty() ? applicable : Collections.max(applicabilities); } | totalApplicability |
33,152 | boolean (@NotNull PsiElement target) { return PropertyReferenceBase.isPropertyPsi(target); } | acceptsTarget |
33,153 | boolean (@NotNull final PsiType qualifierType, @NotNull PsiScopeProcessor processor, @NotNull final PsiElement place, @NotNull ResolveState state) { if (isInAnnotation(place)) return true; final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(qualifierType); if (aClass == null) return true; if (aClass.getLanguage... | processClassMixins |
33,154 | String (PsiMethod element) { PsiClass aClass = element.getContainingClass(); if (aClass != null && aClass.getName() != null) { return "mixed in from " + aClass.getName(); } return "mixed in"; } | getOriginInfoForCategory |
33,155 | String (@NotNull PsiType subjectType) { return "mixed in " + subjectType.getPresentableText(); } | getOriginInfoForMixin |
33,156 | List<PsiAnnotation> (PsiModifierList modifierList) { final ArrayList<PsiAnnotation> result = new ArrayList<>(); for (PsiAnnotation annotation : modifierList.getAnnotations()) { if (GroovyCommonClassNames.GROOVY_LANG_MIXIN.equals(annotation.getQualifiedName())) { result.add(annotation); } } return result; } | getAllMixins |
33,157 | boolean (PsiElement place) { return place.getParent() instanceof GrAnnotation || place.getParent() instanceof GrAnnotationArrayInitializer; } | isInAnnotation |
33,158 | void (GrAnnotationMemberValue value, List<? super PsiClass> mixins) { if (value instanceof GrReferenceExpression) { final PsiElement resolved = ((GrReferenceExpression)value).resolve(); if (resolved instanceof PsiClass) { mixins.add((PsiClass)resolved); } } } | addMixin |
33,159 | String () { return myOriginInfo; } | getOriginInfo |
33,160 | PsiElement () { return myPrototype; } | getPrototype |
33,161 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (element instanceof PsiMethod method && GdkMethodUtil.isCategoryMethod((PsiMethod)element, myType, myPlace, state.get(PsiSubstitutor.KEY))) { String originInfo = getOriginInfoForCategory(method); return super.execute(GrGdkMethodImpl.createGdkMethod... | execute |
33,162 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (element instanceof PsiLocalVariableImpl) { //todo a better hack return true; // the debugger creates a Java code block context and our expressions to evaluate resolve there } if (myResolveTargetKinds == null || myResolveTargetKinds.contains(getDec... | execute |
33,163 | DeclarationKind (PsiElement element) { if (element instanceof PsiMethod) return DeclarationKind.METHOD; if (element instanceof PsiEnumConstant) return DeclarationKind.ENUM_CONST; if (element instanceof PsiField) return DeclarationKind.FIELD; if (element instanceof GroovyProperty) return DeclarationKind.FIELD; if (eleme... | getDeclarationKind |
33,164 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { return super.execute(element, state) || element instanceof PsiField; } | execute |
33,165 | boolean (GroovyResolveResult last) { return !(last.getElement() instanceof PsiField) && last.isAccessible() && last.isStaticsOK() && last.getCurrentFileResolveContext() == null; } | isCorrectLocalVarOrParam |
33,166 | boolean () { return true; } | shouldProcessProperties |
33,167 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (myHint != null && element instanceof PsiNamedElement) { final String expectedName = myHint.getName(state); final String elementName = ((PsiNamedElement)element).getName(); if (expectedName != null && !expectedName.equals(elementName)) { return tru... | execute |
33,168 | boolean (@NotNull PsiElement element, @NotNull ResolveState substitutor) { if (element instanceof PsiMethod && ((PsiMethod)element).isConstructor()) { return true; } super.execute(element, substitutor); return true; } | execute |
33,169 | ResolverProcessor (PsiElement place) { return new CompletionProcessor(place, RESOLVE_KINDS_METHOD_PROPERTY, null); } | createPropertyCompletionProcessor |
33,170 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { return myDelegate.execute(element, state); } | execute |
33,171 | void (@NotNull Event event, @Nullable Object associated) { myDelegate.handleEvent(event, associated); } | handleEvent |
33,172 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (!(element instanceof PsiMember)) return true; if (!((PsiMember)element).hasModifierProperty(PsiModifier.STATIC)) return true; return super.execute(element, state); } | execute |
33,173 | boolean (@NotNull DeclarationKind kind) { assert myResolveTargetKinds != null : "don't invoke shouldProcess if resolveTargets are not declared"; return myResolveTargetKinds.contains(kind); } | shouldProcess |
33,174 | String (@NotNull ResolveState state) { assert myName != null : "don't invoke getName if myName is not declared"; return myName; } | getName |
33,175 | boolean (@NotNull PsiElement element, @NotNull ResolveState state) { if (myStopExecuting) { return false; } if (element instanceof PsiMethod method) { if (method.isConstructor() != myIsConstructor) return true; final PsiElement resolveContext = state.get(RESOLVE_CONTEXT); final SpreadState spreadState = state.get(Sprea... | execute |
33,176 | boolean (@NotNull GroovyMethodResult candidate) { if (myInapplicableCandidates == null) { myInapplicableCandidates = new LinkedHashSet<>(); } return myInapplicableCandidates.add(candidate); } | addInapplicableCandidate |
33,177 | PsiSubstitutor (@NotNull final ResolveState state) { PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY); if (substitutor == null) substitutor = PsiSubstitutor.EMPTY; return substitutor; } | getSubstitutor |
33,178 | Set<GroovyMethodResult> (Set<GroovyMethodResult> candidates) { if (myArgumentTypes == null) return candidates; Set<GroovyMethodResult> result = new LinkedHashSet<>(); for (GroovyMethodResult candidate : candidates) { if (candidate.getElement().getParameterList().getParametersCount() == myArgumentTypes.length) { result.... | filterCorrectParameterCount |
33,179 | GroovyResolveResult[] () { List<GroovyMethodResult> array = getCandidatesInternal(); if (array.size() == 1) return array.toArray(GroovyResolveResult.EMPTY_ARRAY); List<GroovyMethodResult> result = new ArrayList<>(); Iterator<GroovyMethodResult> itr = array.iterator(); result.add(itr.next()); Outer: while (itr.hasNext()... | filterCandidates |
33,180 | boolean () { return hasApplicableCandidates() || myInapplicableCandidates != null && !myInapplicableCandidates.isEmpty(); } | hasCandidates |
33,181 | boolean () { return super.hasCandidates(); } | hasApplicableCandidates |
33,182 | void (@NotNull Event event, Object associated) { super.handleEvent(event, associated); if (JavaScopeProcessorEvent.CHANGE_LEVEL == event && hasApplicableCandidates()) { myStopExecuting = true; } } | handleEvent |
33,183 | PsiElement () { return myPlace; } | getPlace |
33,184 | boolean () { return myIsConstructor; } | isConstructor |
33,185 | void (@NotNull T candidate) { PsiElement element = candidate.getElement(); assert element == null || element.isValid() : getElementInfo(element); if (myCandidates == null) myCandidates = new ArrayList<>(); myCandidates.add(candidate); } | addCandidate |
33,186 | String (@NotNull PsiElement element) { String text; if (element instanceof LightElement) { final PsiElement context = element.getContext(); text = context instanceof LightElement ? context.toString() : context != null ? context.getText() : null; } else { text = element.getText(); } return "invalid resolve candidate: " ... | getElementInfo |
33,187 | List<T> () { return myCandidates == null ? Collections.emptyList() : myCandidates; } | getCandidatesInternal |
33,188 | boolean (@NotNull PsiNamedElement namedElement) { if (namedElement instanceof GrField field) { if (PsiUtil.isAccessible(myPlace, field)) { return true; } for (GrAccessorMethod method : field.getGetters()) { if (PsiUtil.isAccessible(myPlace, method)) { return true; } } final GrAccessorMethod setter = field.getSetter(); ... | isAccessible |
33,189 | boolean (@NotNull PsiNamedElement element, @Nullable PsiElement resolveContext, boolean filterStaticAfterInstanceQualifier) { if (resolveContext instanceof GrImportStatement) return true; if (element instanceof PsiModifierListOwner) { return GrStaticChecker.isStaticsOK((PsiModifierListOwner)element, myPlace, resolveCon... | isStaticsOK |
33,190 | boolean () { return myCandidates != null; } | hasCandidates |
33,191 | String () { return "NameHint: '" + myName + "', " + myResolveTargetKinds + ", Candidates: " + (myCandidates == null ? 0 : myCandidates.size()); } | toString |
33,192 | PsiType () { final PsiElement parent = myPlaceToInferContext.getParent(); if (parent instanceof GrReturnStatement || myExitPoints.getValue().contains(myPlaceToInferContext)) { final GrMethod method = PsiTreeUtil.getParentOfType(parent, GrMethod.class, true, GrClosableBlock.class); if (method != null) { return method.ge... | inferContextType |
33,193 | boolean (PsiElement place) { while (place != null) { if (place instanceof GrMethod || place instanceof GrClosableBlock || place instanceof GrClassInitializer) return true; if (place instanceof GrThrowStatement || place instanceof GrTypeDefinitionBody || place instanceof GroovyFile) return false; place = place.getParent... | canBeExitPoint |
33,194 | PsiSubstitutor (@NotNull PsiSubstitutor substitutor, @NotNull PsiMethod method, @Nullable PsiElement resolveContext) { final PsiTypeParameter[] typeParameters = method.getTypeParameters(); if (myTypeArguments != null && myTypeArguments.length == typeParameters.length) { for (int i = 0; i < typeParameters.length; i++) {... | obtainSubstitutor |
33,195 | PsiSubstitutor (@NotNull PsiMethod method, @NotNull PsiSubstitutor partialSubstitutor, PsiTypeParameter @NotNull [] typeParameters, PsiType @NotNull [] argTypes) { if (typeParameters.length == 0 || myArgumentTypes == null) return partialSubstitutor; final GrSignature erasedSignature = GrClosureSignatureUtil.createSigna... | inferMethodTypeParameters |
33,196 | Deque<InferenceStep> (@NotNull PsiMethod method, PsiTypeParameter @NotNull [] typeParameters, GrClosureParameter[] params, GrClosureSignatureUtil.ArgInfo<PsiType>[] argInfos) { Deque<InferenceStep> inferenceQueue = new ArrayDeque<>(); List<PsiType> parameterTypes = new ArrayList<>(); List<PsiType> argumentTypes = new A... | buildInferenceQueue |
33,197 | InferenceStep (PsiType targetType, PsiType argType, PsiTypeParameter @NotNull [] typeParameters) { if (targetType instanceof PsiClassType && TypesUtil.isClassType(targetType, GroovyCommonClassNames.GROOVY_LANG_CLOSURE)) { PsiType[] parameters = ((PsiClassType)targetType).getParameters(); if (parameters.length != 1) ret... | handleClosure |
33,198 | InferenceStep (@Nullable PsiType targetType, @NotNull PsiType closure, PsiTypeParameter[] typeParameters) { if (!(closure instanceof PsiClassType)) return InferenceStep.EMPTY; if (!(targetType instanceof PsiClassType)) return InferenceStep.EMPTY; ClassResolveResult resolveResult = ((PsiClassType)targetType).resolveGene... | handleConversionOfSAMType |
33,199 | InferenceStep (@NotNull PsiType closure, @Nullable PsiType returnType, PsiTypeParameter[] typeParameters) { PsiType[] parameters = ((PsiClassType)closure).getParameters(); if (parameters.length != 1) return InferenceStep.EMPTY; PsiType[] rightTypes = closure instanceof GrClosureType ? ((GrClosureType)closure).inferPara... | buildReturnTypeClosureStep |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.