Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
72,300 | SearchScope (Editor editor, @NotNull final PsiElement element) { final PsiReferenceExpression referenceExpression = editor != null ? findReferenceExpression(editor) : null; if (referenceExpression != null && element instanceof PsiMethod) { if (!PsiUtil.canBeOverridden((PsiMethod)element)) { return element.getUseScope()... | getSearchScope |
72,301 | boolean (T t) { if (InheritanceUtil.isInheritorOrSelf(t, myElement, true)) return false; return !myElement.getManager().areElementsEquivalent(myElement, t); } | process |
72,302 | int () { return myKind; } | getKind |
72,303 | TailType () { return myTailType; } | getTailType |
72,304 | String () { return expectedNameLazyValue.getValue(); } | getExpectedName |
72,305 | PsiMethod () { return myCalledMethod; } | getCalledMethod |
72,306 | PsiType () { return myType; } | getType |
72,307 | PsiType () { return myDefaultType; } | getDefaultType |
72,308 | boolean (final Object o) { if (this == o) return true; if (!(o instanceof ExpectedTypeInfoImpl that)) return false; if (myKind != that.myKind) return false; if (!myDefaultType.equals(that.myDefaultType)) return false; if (!myTailType.equals(that.myTailType)) return false; if (!myType.equals(that.myType)) return false; ... | equals |
72,309 | int () { int result = myType.hashCode(); result = 31 * result + myDefaultType.hashCode(); result = 31 * result + myKind; result = 31 * result + myTailType.hashCode(); return result; } | hashCode |
72,310 | boolean (ExpectedTypeInfo obj) { return equals((Object)obj); } | equals |
72,311 | String () { return "ExpectedTypeInfo[type='" + myType + "' kind='" + myKind + "']"; } | toString |
72,312 | PsiType (@NotNull PsiElement context, @NotNull PsiType type) { if (type instanceof PsiClassType && ((PsiClassType)type).resolve() == null) { String className = ((PsiClassType)type).getClassName(); int typeParamCount = ((PsiClassType)type).getParameterCount(); Project project = context.getProject(); PsiResolveHelper hel... | fixUnresolvedType |
72,313 | ExpectedTypesProvider (@NotNull Project project) { return project.getService(ExpectedTypesProvider.class); } | getInstance |
72,314 | ExpectedTypeInfo (@NotNull PsiType type, @ExpectedTypeInfo.Type int kind, PsiType defaultType, @NotNull TailType tailType) { return createInfoImpl(type, kind, defaultType, tailType); } | createInfo |
72,315 | ExpectedTypeInfoImpl (@NotNull PsiType type, PsiType defaultType) { return createInfoImpl(type, ExpectedTypeInfo.TYPE_OR_SUBTYPE, defaultType, TailTypes.noneType()); } | createInfoImpl |
72,316 | ExpectedTypeInfoImpl (@NotNull PsiType type, @ExpectedTypeInfo.Type int kind, PsiType defaultType, @NotNull TailType tailType) { return new ExpectedTypeInfoImpl(type, kind, defaultType, tailType, null, ExpectedTypeInfoImpl.NULL); } | createInfoImpl |
72,317 | ExpectedTypeInfoImpl (@NotNull PsiType type, int kind, PsiType defaultType, @NotNull TailType tailType, PsiMethod calledMethod, Supplier<String> expectedName) { return new ExpectedTypeInfoImpl(type, kind, defaultType, tailType, calledMethod, expectedName); } | createInfoImpl |
72,318 | ExpectedTypeInfo (@Nullable PsiExpression expr) { ExpectedTypeInfo[] expectedTypes = getExpectedTypes(expr, true, ourGlobalScopeClassProvider, false, false, 1); if (expectedTypes.length > 0) { return expectedTypes[0]; } return null; } | getSingleExpectedTypeForCompletion |
72,319 | PsiFunctionalExpression (PsiExpression expr) { PsiElement parent = expr.getParent(); if (expr instanceof PsiFunctionalExpression && parent instanceof PsiExpressionStatement && !(parent.getParent() instanceof PsiSwitchLabeledRuleStatement)) { return (PsiFunctionalExpression)expr; } parent = PsiTreeUtil.skipParentsOfType... | extractFunctionalExpression |
72,320 | void (@NotNull PsiType type, @NotNull PsiTypeVisitor<? extends PsiType> visitor, @NotNull Set<? super PsiType> typeSet) { PsiType accepted = type.accept(visitor); if (accepted != null) typeSet.add(accepted); } | processType |
72,321 | void (@NotNull PsiPrimitiveType type, @NotNull PsiTypeVisitor<? extends PsiType> visitor, @NotNull Set<? super PsiType> set) { if (type.equals(PsiTypes.booleanType()) || type.equals(PsiTypes.voidType()) || type.equals(PsiTypes.nullType())) return; for (int i = 0; ; i++) { final PsiType primitive = PRIMITIVE_TYPES[i]; p... | processPrimitiveTypeAndSubtypes |
72,322 | void (@NotNull PsiType type, @NotNull PsiTypeVisitor<? extends PsiType> visitor, @NotNull Project project, @NotNull Set<? super PsiType> set, @NotNull Set<? super PsiType> visited) { if (!visited.add(type)) return; if (type instanceof PsiPrimitiveType) { if (type.equals(PsiTypes.booleanType()) || type.equals(PsiTypes.v... | processAllSuperTypes |
72,323 | void (@NotNull PsiParenthesizedExpression expression) { PsiElement parent = expression.getParent(); if (parent != null) { final MyParentVisitor visitor = new MyParentVisitor(expression, myForCompletion, myClassProvider, myVoidable, myUsedAfter, myMaxCandidates); parent.accept(visitor); for (final ExpectedTypeInfo info ... | visitParenthesizedExpression |
72,324 | void (@NotNull final PsiAnnotationMethod method) { if (myExpr == method.getDefaultValue()) { final PsiType type = method.getReturnType(); if (type != null) { myResult.add(createInfoImpl(type, ExpectedTypeInfo.TYPE_OR_SUBTYPE, type, TailTypes.semicolonType())); } } } | visitAnnotationMethod |
72,325 | void (@NotNull PsiReferenceExpression expression) { if (myForCompletion) { final MyParentVisitor visitor = new MyParentVisitor(expression, true, myClassProvider, myVoidable, myUsedAfter, myMaxCandidates); expression.getParent().accept(visitor); myResult.addAll(visitor.myResult); return; } String referenceName = express... | visitReferenceExpression |
72,326 | void (@NotNull PsiExpressionStatement statement) { if (statement.getParent() instanceof PsiSwitchLabeledRuleStatement) { PsiSwitchBlock block = ((PsiSwitchLabeledRuleStatement)statement.getParent()).getEnclosingSwitchBlock(); if (block instanceof PsiSwitchExpression) { Collections.addAll(myResult, getExpectedTypes((Psi... | visitExpressionStatement |
72,327 | void (@NotNull PsiYieldStatement statement) { PsiSwitchExpression expression = statement.findEnclosingExpression(); if (expression != null) { Collections.addAll(myResult, getExpectedTypes(expression, myForCompletion)); } } | visitYieldStatement |
72,328 | void (@NotNull PsiMethodCallExpression expression) { myExpr = (PsiExpression)myExpr.getParent(); expression.getParent().accept(this); } | visitMethodCallExpression |
72,329 | void (@NotNull PsiArrayInitializerMemberValue initializer) { PsiElement parent = initializer.getParent(); while (parent instanceof PsiArrayInitializerMemberValue) { parent = parent.getParent(); } final PsiType type; if (parent instanceof PsiNameValuePair) { type = getAnnotationMethodType((PsiNameValuePair)parent); } el... | visitAnnotationArrayInitializer |
72,330 | void (@NotNull PsiNameValuePair pair) { final PsiType type = getAnnotationMethodType(pair); if (type == null) return; if (type instanceof PsiArrayType) { PsiType componentType = ((PsiArrayType)type).getComponentType(); myResult.add(createInfoImpl(componentType, componentType)); } else { myResult.add(createInfoImpl(type... | visitNameValuePair |
72,331 | PsiType (@NotNull final PsiNameValuePair pair) { final PsiReference reference = pair.getReference(); if (reference != null) { final PsiElement method = reference.resolve(); if (method instanceof PsiMethod) { return ((PsiMethod)method).getReturnType(); } } return null; } | getAnnotationMethodType |
72,332 | void (@NotNull PsiLambdaExpression lambdaExpression) { super.visitLambdaExpression(lambdaExpression); final PsiType functionalInterfaceType = lambdaExpression.getFunctionalInterfaceType(); final PsiMethod scopeMethod = LambdaUtil.getFunctionalInterfaceMethod(functionalInterfaceType); if (scopeMethod != null) { visitMet... | visitLambdaExpression |
72,333 | void (@NotNull PsiReturnStatement statement) { final PsiMethod method; final PsiType type; final boolean tailTypeSemicolon; final NavigatablePsiElement psiElement = PsiTreeUtil.getParentOfType(statement, PsiLambdaExpression.class, PsiMethod.class); if (psiElement instanceof PsiLambdaExpression) { final PsiType function... | visitReturnStatement |
72,334 | void (final PsiMethod scopeMethod, PsiType type, boolean tailTypeSemicolon) { if (type != null) { Supplier<String> expectedName; if (PropertyUtilBase.isSimplePropertyAccessor(scopeMethod)) { expectedName = () -> PropertyUtilBase.getPropertyName(scopeMethod); } else { expectedName = ExpectedTypeInfoImpl.NULL; } myResult... | visitMethodReturnType |
72,335 | void (@NotNull PsiIfStatement statement) { myResult.add( createInfoImpl(PsiTypes.booleanType(), ExpectedTypeInfo.TYPE_STRICTLY, PsiTypes.booleanType(), JavaTailTypes.IF_RPARENTH)); } | visitIfStatement |
72,336 | void (@NotNull PsiWhileStatement statement) { myResult.add( createInfoImpl(PsiTypes.booleanType(), ExpectedTypeInfo.TYPE_STRICTLY, PsiTypes.booleanType(), JavaTailTypes.WHILE_RPARENTH)); } | visitWhileStatement |
72,337 | void (@NotNull PsiDoWhileStatement statement) { myResult.add( createInfoImpl(PsiTypes.booleanType(), ExpectedTypeInfo.TYPE_STRICTLY, PsiTypes.booleanType(), JavaTailTypes.WHILE_RPARENTH)); } | visitDoWhileStatement |
72,338 | void (@NotNull PsiForStatement statement) { if (myExpr.equals(statement.getCondition())) { myResult.add(createInfoImpl(PsiTypes.booleanType(), ExpectedTypeInfo.TYPE_STRICTLY, PsiTypes.booleanType(), TailTypes.semicolonType())); } } | visitForStatement |
72,339 | void (@NotNull PsiAssertStatement statement) { if (statement.getAssertDescription() == myExpr) { final PsiClassType stringType = PsiType.getJavaLangString(myExpr.getManager(), myExpr.getResolveScope()); myResult.add(createInfoImpl(stringType, ExpectedTypeInfo.TYPE_STRICTLY, stringType, TailTypes.semicolonType())); } el... | visitAssertStatement |
72,340 | void (@NotNull PsiSwitchLabelStatement statement) { processGuard(statement); } | visitSwitchLabelStatement |
72,341 | void (@NotNull PsiSwitchLabeledRuleStatement statement) { processGuard(statement); } | visitSwitchLabeledRuleStatement |
72,342 | void (@NotNull PsiSwitchLabelStatementBase statement) { if (!myExpr.equals(statement.getGuardExpression())) { return; } final PsiSwitchBlock switchBlock = statement.getEnclosingSwitchBlock(); if (switchBlock != null) { final TailType caseTail = JavaTailTypes.forSwitchLabel(switchBlock); myResult.add(createInfoImpl(PsiT... | processGuard |
72,343 | void (@NotNull PsiForeachStatement statement) { if (myExpr.equals(statement.getIteratedValue())) { PsiParameter iterationParameter = statement.getIterationParameter(); PsiType type = iterationParameter.getType(); if (PsiTypes.nullType().equals(type)) return; PsiType arrayType = type.createArrayType(); myResult.add(crea... | visitForeachStatement |
72,344 | void (@NotNull PsiSwitchStatement statement) { processSwitchBlock(statement); } | visitSwitchStatement |
72,345 | void (@NotNull PsiSwitchExpression expression) { processSwitchBlock(expression); } | visitSwitchExpression |
72,346 | void (@NotNull PsiSwitchBlock statement) { if (statement.getExpression() == this.myExpr) { List<ExpectedTypeInfo> collectedTypes = collectFromLabels(statement); if (!collectedTypes.isEmpty()) { myResult.addAll(collectedTypes); return; } } myResult.add(createInfoImpl(PsiTypes.intType(), PsiTypes.intType())); LanguageLev... | processSwitchBlock |
72,347 | List<ExpectedTypeInfo> (@NotNull PsiSwitchBlock statement) { List<PsiType> labeledExpressionTypes = new ArrayList<>(); List<PsiType> labeledPatternsTypes = new ArrayList<>(); List<ExpectedTypeInfo> result = new ArrayList<>(); boolean mustBeReference = false; PsiCodeBlock body = statement.getBody(); if (body == null) { ... | collectFromLabels |
72,348 | List<ExpectedTypeInfo> (@NotNull List<PsiType> expectedTypes, @NotNull PsiSwitchBlock statement) { PsiManager manager = statement.getManager(); if(manager == null) return Collections.emptyList(); PsiType lub = getLeastUpperBound(expectedTypes, manager); if (lub == null) return Collections.emptyList(); return Collection... | findExpectedTypesForPatterns |
72,349 | PsiType (@NotNull List<PsiType> types, @NotNull PsiManager manager) { if (types.isEmpty()) return null; Iterator<PsiType> iterator = types.iterator(); PsiType accumulator = iterator.next(); while (iterator.hasNext()) { PsiType type = iterator.next(); accumulator = GenericsUtil.getLeastUpperBound(accumulator, type, mana... | getLeastUpperBound |
72,350 | List<ExpectedTypeInfo> (@NotNull List<PsiType> expectedTypes, boolean mustBeReference, @NotNull PsiSwitchBlock context) { List<ExpectedTypeInfo> result = new ArrayList<>(); Set<PsiType> processedTypes = new HashSet<>(); for (PsiType expectedType : expectedTypes) { if (expectedType == null) { continue; } if (expectedTyp... | findExpectedTypesForExpressions |
72,351 | void (@NotNull Set<PsiType> processedTypes, @NotNull PsiType expectedType, @NotNull List<ExpectedTypeInfo> result, @Nullable PsiElement context) { addIfNotExist(processedTypes, expectedType, result, createInfoImpl(expectedType, expectedType)); if (context!=null && expectedType instanceof PsiPrimitiveType primitiveType)... | addWithWrapper |
72,352 | void (@NotNull Set<PsiType> processedTypes, @NotNull PsiType expectedType, @NotNull List<ExpectedTypeInfo> result, @NotNull ExpectedTypeInfo expectedTypeInfo) { if (!processedTypes.contains(expectedType)) { processedTypes.add(expectedType); result.add(expectedTypeInfo); } } | addIfNotExist |
72,353 | void (@NotNull PsiSynchronizedStatement statement) { PsiElementFactory factory = JavaPsiFacade.getElementFactory(statement.getProject()); PsiType objectType = factory.createTypeByFQClassName(CommonClassNames.JAVA_LANG_OBJECT, myExpr.getResolveScope()); myResult.add(createInfoImpl(objectType, objectType)); } | visitSynchronizedStatement |
72,354 | void (@NotNull PsiVariable variable) { if (variable instanceof PsiLocalVariable local && myForCompletion && myHops < MAX_VAR_HOPS) { PsiTypeElement typeElement = local.getTypeElement(); if (typeElement.isInferredType()) { PsiElement block = PsiUtil.getVariableCodeBlock(variable, null); if (block != null) { myHops++; Li... | visitVariable |
72,355 | void (@NotNull PsiAssignmentExpression assignment) { if (myExpr.equals(assignment.getRExpression())) { PsiExpression lExpr = assignment.getLExpression(); PsiType type = lExpr.getType(); if (type != null) { TailType tailType = getAssignmentRValueTailType(assignment); Supplier<String> expectedName = ExpectedTypeInfoImpl.... | visitAssignmentExpression |
72,356 | TailType (@NotNull PsiAssignmentExpression assignment) { if (assignment.getParent() instanceof PsiExpressionStatement) { if (!(assignment.getParent().getParent() instanceof PsiForStatement forStatement)) { return TailTypes.semicolonType(); } if (!assignment.getParent().equals(forStatement.getUpdate())) { return TailTyp... | getAssignmentRValueTailType |
72,357 | void (@NotNull PsiExpressionList list) { PsiResolveHelper helper = JavaPsiFacade.getInstance(list.getProject()).getResolveHelper(); PsiElement parent = list.getParent(); if (parent instanceof PsiMethodCallExpression methodCall) { CandidateInfo[] candidates = helper.getReferencedMethodCandidates(methodCall, false, true)... | visitExpressionList |
72,358 | void (PsiSwitchBlock switchBlock) { if (switchBlock != null) { PsiExpression expression = switchBlock.getExpression(); if (expression != null) { PsiType type = expression.getType(); if (type != null) { myResult.add(createInfoImpl(type, ExpectedTypeInfo.TYPE_OR_SUBTYPE, type, JavaTailTypes.forSwitchLabel(switchBlock)));... | handleCaseElementList |
72,359 | void (@NotNull PsiCaseLabelElementList list) { PsiElement parent = list.getParent(); if (parent instanceof PsiSwitchLabelStatementBase) { PsiSwitchBlock switchBlock = ((PsiSwitchLabelStatementBase)parent).getEnclosingSwitchBlock(); handleCaseElementList(switchBlock); } } | visitCaseLabelElementList |
72,360 | void (@NotNull final PsiEnumConstant enumConstant, @NotNull final PsiExpressionList list) { final PsiClass aClass = enumConstant.getContainingClass(); if (aClass != null) { LOG.assertTrue(aClass.isEnum()); getExpectedTypesForConstructorCall(aClass, list, PsiSubstitutor.EMPTY); } } | getExpectedArgumentsTypesForEnumConstant |
72,361 | void (@NotNull final PsiNewExpression newExpr, @NotNull final PsiExpressionList list) { if (PsiDiamondType.hasDiamond(newExpr)) { final List<CandidateInfo> candidates = PsiDiamondTypeImpl.collectStaticFactories(newExpr); if (candidates != null) { final PsiExpressionList argumentList = Objects.requireNonNull(newExpr.get... | getExpectedArgumentsTypesForNewExpression |
72,362 | void (@NotNull PsiClass referencedClass, @NotNull PsiExpressionList argumentList, @NotNull PsiSubstitutor substitutor) { List<CandidateInfo> array = new ArrayList<>(); for (PsiMethod constructor : referencedClass.getConstructors()) { array.add(new MethodCandidateInfo(constructor, substitutor, false, false, argumentList... | getExpectedTypesForConstructorCall |
72,363 | void (@NotNull PsiPolyadicExpression expr) { PsiExpression[] operands = expr.getOperands(); final int index = Arrays.asList(operands).indexOf(myExpr); if (index < 0) return; // broken syntax IElementType op = expr.getOperationTokenType(); PsiExpression anotherExpr = index > 0 ? operands[0] : 1 < operands.length ? opera... | visitPolyadicExpression |
72,364 | ExpectedTypeInfo (@Nullable PsiExpression anotherExpr) { PsiType anotherType = anotherExpr != null ? anotherExpr.getType() : null; if (anotherType == null) { return null; } Supplier<String> expectedName = ExpectedTypeInfoImpl.NULL; if (anotherExpr instanceof PsiReferenceExpression) { PsiElement refElement = ((PsiRefere... | getEqualsType |
72,365 | void (@NotNull PsiPrefixExpression expr) { IElementType i = expr.getOperationTokenType(); final PsiType type = expr.getType(); final PsiElement parent = expr.getParent(); final TailType tailType = parent instanceof PsiAssignmentExpression && ((PsiAssignmentExpression)parent).getRExpression() == expr ? getAssignmentRVal... | visitPrefixExpression |
72,366 | void (@NotNull PsiPostfixExpression expr) { if (myForCompletion) return; PsiType type = expr.getType(); ExpectedTypeInfoImpl info; if (myUsedAfter && type != null) { info = createInfoImpl(type, ExpectedTypeInfo.TYPE_STRICTLY, type, TailTypes.noneType()); } else { if (type != null) { info = createInfoImpl(type, type ins... | visitPostfixExpression |
72,367 | void (@NotNull PsiArrayInitializerExpression expr) { PsiElement pParent = expr.getParent(); PsiType arrayType = null; if (pParent instanceof PsiVariable) { arrayType = ((PsiVariable)pParent).getType(); } else if (pParent instanceof PsiNewExpression) { arrayType = ((PsiNewExpression)pParent).getType(); } else if (pParen... | visitArrayInitializerExpression |
72,368 | void (@NotNull PsiNewExpression expression) { PsiExpression[] arrayDimensions = expression.getArrayDimensions(); for (PsiExpression dimension : arrayDimensions) { if (myExpr.equals(dimension)) { myResult.add(createInfoImpl(PsiTypes.intType(), PsiTypes.intType())); return; } } } | visitNewExpression |
72,369 | void (@NotNull PsiArrayAccessExpression expr) { if (myExpr.equals(expr.getIndexExpression())) { myResult.add(createInfoImpl(PsiTypes.intType(), PsiTypes.intType())); } else if (myExpr.equals(expr.getArrayExpression())) { if (myForCompletion) { myExpr = (PsiExpression)myExpr.getParent(); expr.getParent().accept(this); r... | visitArrayAccessExpression |
72,370 | void (@NotNull PsiConditionalExpression expr) { if (myExpr.equals(expr.getCondition())) { if (myForCompletion) { myExpr = expr; myExpr.getParent().accept(this); return; } myResult.add(createInfoImpl(PsiTypes.booleanType(), ExpectedTypeInfo.TYPE_STRICTLY, PsiTypes.booleanType(), TailTypes.noneType())); } else if (myExpr... | visitConditionalExpression |
72,371 | void (@NotNull PsiThrowStatement statement) { if (statement.getException() == myExpr) { PsiManager manager = statement.getManager(); PsiType throwableType = JavaPsiFacade.getElementFactory(manager.getProject()).createTypeByFQClassName(CommonClassNames.JAVA_LANG_THROWABLE, myExpr.getResolveScope()); PsiElement container... | visitThrowStatement |
72,372 | void (@NotNull JavaCodeFragment codeFragment) { if (codeFragment instanceof PsiExpressionCodeFragment) { final PsiType type = ((PsiExpressionCodeFragment)codeFragment).getExpectedType(); if (type != null) { myResult.add(createInfoImpl(type, type)); } } } | visitCodeFragment |
72,373 | PsiTypeParameter (int index, PsiMethod method) { PsiTypeParameter returnTypeParameter = ObjectUtils.tryCast(PsiUtil.resolveClassInClassTypeOnly(method.getReturnType()), PsiTypeParameter.class); if (returnTypeParameter == null || returnTypeParameter.getOwner() != method) return null; PsiParameter[] parameters = method.g... | getReturnTypeParameterNotMentionedPreviously |
72,374 | TailType (@NotNull final PsiExpression argument, final int index, @NotNull final PsiMethod method, @NotNull final PsiSubstitutor substitutor, final PsiParameter @NotNull [] params) { if (index >= params.length || index == params.length - 2 && params[index + 1].isVarArgs()) { return TailTypes.noneType(); } if (index == ... | getMethodArgumentTailType |
72,375 | PsiCall (@NotNull PsiExpression argument) { PsiElement expressionList = argument.getParent(); if (expressionList instanceof PsiExpressionList) { PsiElement call = expressionList.getParent(); if (call instanceof PsiCall) { PsiCall originalCall = CompletionUtil.getOriginalElement((PsiCall)call); if (originalCall != null ... | getCompletedOuterCall |
72,376 | void (@NotNull final PsiExpression argument, final boolean forCompletion, final PsiExpression @NotNull [] args, final int index, @NotNull final PsiMethod method, @NotNull final PsiSubstitutor substitutor, @NotNull final Set<? super ExpectedTypeInfo> array) { LOG.assertTrue(substitutor.isValid()); PsiParameter[] paramet... | inferMethodCallArgumentTypes |
72,377 | PsiType (@NotNull final PsiMethod method, final PsiSubstitutor substitutor, @NotNull final PsiType parameterType, @NotNull final PsiExpression argument, @Nullable PsiExpression @NotNull [] args, int index) { final PsiClass containingClass = method.getContainingClass(); if (containingClass == null) return parameterType;... | getDefaultType |
72,378 | PsiType (@NotNull PsiParameter parameter, @NotNull PsiSubstitutor substitutor) { PsiType type = parameter.getType(); LOG.assertTrue(type.isValid()); if (parameter.isVarArgs()) { if (type instanceof PsiArrayType) { type = ((PsiArrayType)type).getComponentType(); } else { LOG.error("Vararg parameter with non-array type. ... | getParameterType |
72,379 | NullableComputable<String> (@NotNull final PsiVariable variable) { return () -> { final String name = variable.getName(); if (name == null) return null; JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(variable.getProject()); VariableKind variableKind = codeStyleManager.getVariableKind(variable)... | getPropertyName |
72,380 | List<ExpectedTypeInfo> () { PsiType objType = PsiType.getJavaLangObject(myExpr.getManager(), myExpr.getResolveScope()).createArrayType(); ExpectedTypeInfo info = createInfoImpl(objType, objType); ExpectedTypeInfo info1 = createInfoImpl(PsiTypes.doubleType().createArrayType(), PsiTypes.intType().createArrayType()); PsiT... | anyArrayType |
72,381 | Set<PsiMethod> (PsiMethod[] methods) { LinkedHashSet<PsiMethod> psiMethods = new LinkedHashSet<>(); for (PsiMethod m : methods) { if (m.hasModifierProperty(PsiModifier.STATIC) || m.hasModifierProperty(PsiModifier.PRIVATE)) { psiMethods.add(m); } else { PsiMethod[] superMethods = m.findDeepestSuperMethods(); if (superMe... | mapToDeepestSuperMethods |
72,382 | TailType (@NotNull PsiElement call, @Nullable PsiType returnType, @NotNull PsiMethod method) { if (method.isConstructor() && call instanceof PsiMethodCallExpression && ((PsiMethodCallExpression)call).getMethodExpression() instanceof PsiSuperExpression) { return JavaTailTypes.CALL_RPARENTH_SEMICOLON; } final boolean cha... | getFinalCallParameterTailType |
72,383 | boolean (@NotNull InsertionContext context) { return CommaTailType.INSTANCE.isApplicable(context); } | isApplicable |
72,384 | int (Editor editor, int tailOffset) { int result = CommaTailType.INSTANCE.processTail(editor, tailOffset); if (myOriginalCall.isValid()) { PsiDocumentManager.getInstance(myOriginalCall.getProject()).commitDocument(editor.getDocument()); if (myOriginalCall.isValid()) ParameterHintsPass.asyncUpdate(myOriginalCall, editor... | processTail |
72,385 | boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; CommaTailTypeWithSyncHintUpdate update = (CommaTailTypeWithSyncHintUpdate)o; return myOriginalCall.equals(update.myOriginalCall); } | equals |
72,386 | int () { return Objects.hash(myOriginalCall); } | hashCode |
72,387 | int (PsiElement elementInHost, PsiFile regexp) { final PsiExpressionList list = PsiTreeUtil.getParentOfType(elementInHost, PsiExpressionList.class); if (list != null) { PsiExpression[] expressions = list.getExpressions(); if (expressions.length == 2 && PsiTypes.intType().equals(expressions[1].getType())) { final Object... | getFlags |
72,388 | JavaProjectCodeInsightSettings (@NotNull Project project) { return project.getService(JavaProjectCodeInsightSettings.class); } | getSettings |
72,389 | boolean (@NotNull String name) { for (String excluded : excludedNames) { if (nameMatches(name, excluded)) { return true; } } for (String excluded : CodeInsightSettings.getInstance().EXCLUDED_PACKAGES) { if (nameMatches(name, excluded)) { return true; } } return false; } | isExcluded |
72,390 | boolean (@NotNull String name, String excluded) { int length = getMatchingLength(name, excluded); return length > 0 && (name.length() == length || name.charAt(length) == '.'); } | nameMatches |
72,391 | int (@NotNull String name, String excluded) { if (name.startsWith(excluded)) { return excluded.length(); } if (excluded.indexOf('*') >= 0) { Matcher matcher = ourPatterns.get(excluded).matcher(name); if (matcher.lookingAt()) { return matcher.end(); } } return -1; } | getMatchingLength |
72,392 | JavaProjectCodeInsightSettings () { return this; } | getState |
72,393 | void (@NotNull JavaProjectCodeInsightSettings state) { XmlSerializerUtil.copyBean(state, this); } | loadState |
72,394 | void (Project project, Disposable parentDisposable, String... excludes) { final JavaProjectCodeInsightSettings instance = getSettings(project); assert instance.excludedNames.isEmpty(); instance.excludedNames = Arrays.asList(excludes); Disposer.register(parentDisposable, new Disposable() { @Override public void dispose(... | setExcludedNames |
72,395 | void () { instance.excludedNames = new ArrayList<>(); } | dispose |
72,396 | boolean (@Nullable PsiModifierListOwner owner) { if (owner instanceof PsiPackage || owner instanceof PsiClass) return true; if (owner instanceof PsiParameter) { owner = PsiTreeUtil.getParentOfType(owner, PsiMethod.class, true); } if (owner instanceof PsiField || owner instanceof PsiMethod) { return PsiTreeUtil.getParen... | canBeExternallyAnnotated |
72,397 | PsiModifierListOwner () { return owner; } | getOwner |
72,398 | String () { return annotationFQName; } | getAnnotationFQName |
72,399 | PsiNameValuePair[] () { return values; } | getValues |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.