Unnamed: 0 int64 0 305k | body stringlengths 7 52.9k | name stringlengths 1 185 |
|---|---|---|
24,100 | boolean (PsiLanguageInjectionHost host) { return host instanceof PsiLiteralExpression; } | isApplicableTo |
24,101 | BaseInjection (@NotNull PsiElement host, @Nullable Ref<? super PsiElement> commentRef) { PsiFile containingFile = host.getContainingFile(); boolean compiled = containingFile != null && containingFile.getOriginalFile() instanceof PsiCompiledFile; return compiled ? null : super.findCommentInjection(host, commentRef); } | findCommentInjection |
24,102 | boolean (final Language language, final PsiLanguageInjectionHost psiElement) { if (!isMine(psiElement)) return false; return doInjectInJava(psiElement.getProject(), psiElement, psiElement, language.getID()); } | addInjectionInPlace |
24,103 | boolean (final PsiLanguageInjectionHost psiElement) { if (!isMine(psiElement)) return false; final HashMap<BaseInjection, Pair<PsiMethod, Integer>> injectionsMap = new HashMap<>(); final ArrayList<PsiElement> annotations = new ArrayList<>(); final PsiLiteralExpression host = (PsiLiteralExpression)psiElement; final Proj... | removeInjectionInPlace |
24,104 | boolean (final PsiLanguageInjectionHost psiElement) { if (!isMine(psiElement)) return false; final HashMap<BaseInjection, Pair<PsiMethod, Integer>> injectionsMap = new HashMap<>(); final ArrayList<PsiElement> annotations = new ArrayList<>(); final PsiLiteralExpression host = (PsiLiteralExpression)psiElement; final Proj... | editInjectionInPlace |
24,105 | BaseInjection (final Project project, final MethodParameterInjection methodParameterInjection) { final MethodParameterPanel panel = new MethodParameterPanel(methodParameterInjection, project); panel.reset(); String helpID = "reference.settings.injection.language.injection.settings.java.parameter"; return showEditInject... | showInjectionUI |
24,106 | BaseInjection (final Element element) { return new BaseInjection(JAVA_SUPPORT_ID); } | createInjection |
24,107 | boolean (final Project project, @NotNull final PsiElement psiElement, PsiLanguageInjectionHost host, final String languageId) { final PsiElement target = ContextComputationProcessor.getTopLevelInjectionTarget(psiElement); final PsiElement parent = target.getParent(); if (parent instanceof PsiReturnStatement || parent i... | doInjectInJava |
24,108 | boolean (final Project project, final PsiModifierListOwner modifierListOwner, @NotNull PsiLanguageInjectionHost host, final String languageId) { return doAddLanguageAnnotation(project, modifierListOwner, host, languageId, host1 -> { final Configuration.AdvancedConfiguration configuration = Configuration.getProjectInsta... | doAddLanguageAnnotation |
24,109 | boolean (Module module) { if (module == null) return false; return JavaPsiFacade.getInstance(module.getProject()) .findClass(AnnotationUtil.LANGUAGE, GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module)) != null; } | isAnnotationsJarInPath |
24,110 | boolean (@NotNull Project project, @Nullable final PsiModifierListOwner modifierListOwner, @NotNull final PsiLanguageInjectionHost host, final String languageId, Processor<? super PsiLanguageInjectionHost> annotationFixer) { if (modifierListOwner == null) return false; final Task.WithResult<Boolean, RuntimeException> t... | doAddLanguageAnnotation |
24,111 | Boolean (@NotNull ProgressIndicator indicator) { return ReadAction.nonBlocking(() -> isAnnotationsJarInPath(ModuleUtilCore.findModuleForPsiElement(modifierListOwner))) .executeSynchronously(); } | compute |
24,112 | boolean (@NotNull final Project project, @Nullable final PsiMethod psiMethod, final int parameterIndex, @NotNull PsiLanguageInjectionHost host, @NotNull final String languageId) { if (psiMethod == null) return false; if (parameterIndex < -1) return false; if (parameterIndex >= psiMethod.getParameterList().getParameters... | doInjectInJavaMethod |
24,113 | MethodParameterInjection (@NotNull PsiMethod psiMethod, int parameterIndex, @NotNull String languageId) { final PsiClass containingClass = psiMethod.getContainingClass(); assert containingClass != null; final String className = containingClass.getQualifiedName(); assert className != null; final MethodParameterInjection... | makeParameterInjection |
24,114 | int (final PsiElement target, final PsiExpressionList parent) { final int idx = Arrays.<PsiElement>asList(parent.getExpressions()).indexOf(target); return idx < 0? -2 : idx; } | findParameterIndex |
24,115 | PsiMethod (final PsiElement parent) { if (parent instanceof PsiNameValuePair) { final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(parent, PsiAnnotation.class); if (annotation != null) { final PsiJavaCodeReferenceElement referenceElement = annotation.getNameReferenceElement(); if (referenceElement != null) { ... | findPsiMethod |
24,116 | void (final Project project, final MethodParameterInjection template, PsiFile psiFile, final PsiMethod contextMethod) { final Configuration configuration = InjectorUtils.getEditableInstance(project); final BaseInjection baseTemplate = new BaseInjection(template.getSupportId()).copyFrom(template); final MethodParameterI... | doEditInjection |
24,117 | void (@NotNull Project project, @Nullable PsiFile psiFile, @NotNull Configuration configuration, @NotNull MethodParameterInjection injection, @Nullable BaseInjection originalInjection) { BaseInjection newInjection = new BaseInjection(injection.getSupportId()).copyFrom(injection); if (originalInjection != null) { newInj... | mergePlacesAndAddToConfiguration |
24,118 | void (PsiLiteralExpression host, Configuration configuration, JavaLanguageInjectionSupport support, final HashMap<BaseInjection, Pair<PsiMethod, Integer>> injectionsMap, final ArrayList<? super PsiElement> annotations) { new ConcatenationInjector.InjectionProcessor(configuration, support, host) { @Override protected bo... | collectInjections |
24,119 | boolean (PsiElement comment, BaseInjection injection) { ContainerUtil.addAll(annotations, comment); return true; } | processCommentInjectionInner |
24,120 | boolean (PsiModifierListOwner owner, PsiAnnotation[] annos) { ContainerUtil.addAll(annotations, annos); return true; } | processAnnotationInjectionInner |
24,121 | boolean (BaseInjection injection, PsiModifierListOwner owner, PsiMethod method, int paramIndex) { injectionsMap.put(injection, Pair.create(method, paramIndex)); return true; } | processXmlInjections |
24,122 | MethodParameterInjection (final Project project, final BaseInjection injection, final PsiMethod contextMethod, final boolean includeAllPlaces) { final PsiClass[] classes; final String className; if (contextMethod != null) { final PsiClass psiClass = contextMethod.getContainingClass(); className = psiClass == null ? "" ... | createFrom |
24,123 | String (final PsiMethod method, final int parameterIndex) { final PsiClass psiClass = method.getContainingClass(); final String className = psiClass == null ? "" : StringUtil.notNullize(psiClass.getQualifiedName()); final String signature = createMethodInfo(method).getMethodSignature(); return MethodParameterInjection.... | getPatternStringForJavaPlace |
24,124 | AnAction[] (final Project project, final Consumer<? super BaseInjection> consumer) { return new AnAction[] { new AnAction(IntelliLangBundle.message("java.parameter"), null, IconManager.getInstance().getPlatformIcon(com.intellij.ui.PlatformIcons.Parameter)) { @Override public void actionPerformed(@NotNull final AnAction... | createAddActions |
24,125 | void (@NotNull final AnActionEvent e) { final BaseInjection injection = showInjectionUI(project, new MethodParameterInjection()); if (injection != null) consumer.consume(injection); } | actionPerformed |
24,126 | AnAction (final Project project, final Factory<? extends BaseInjection> producer) { return new AnAction() { @Override public void actionPerformed(@NotNull final AnActionEvent e) { final BaseInjection originalInjection = producer.create(); final MethodParameterInjection injection = createFrom(project, originalInjection,... | createEditAction |
24,127 | void (@NotNull final AnActionEvent e) { final BaseInjection originalInjection = producer.create(); final MethodParameterInjection injection = createFrom(project, originalInjection, null, false); final boolean mergeEnabled = !project.isInitialized() || JavaPsiFacade.getInstance(project).findClass(injection.getClassName(... | actionPerformed |
24,128 | void (final BaseInjection injection, final SimpleColoredText presentation, final boolean isSelected) { final Matcher matcher = ourPresentationPattern.matcher(injection.getDisplayName()); if (matcher.matches()) { presentation.append(matcher.group(1), SimpleTextAttributes.REGULAR_ATTRIBUTES); presentation.append(matcher.... | setupPresentation |
24,129 | String () { return "reference.settings.injection.language.injection.settings.java.parameter"; } | getHelpId |
24,130 | void (@NotNull PsiReferenceRegistrar registrar) { final Configuration configuration = Configuration.getInstance(); registerUastReferenceProvider(registrar, injectionHostUExpression().annotationParam(StandardPatterns.string().with( new PatternCondition<>( "isLanguageAnnotation") { @Override public boolean accepts(@NotNu... | registerReferenceProviders |
24,131 | boolean (@NotNull final String s, final ProcessingContext context) { return Objects.equals(configuration.getAdvancedConfiguration().getLanguageAnnotationClass(), s); } | accepts |
24,132 | boolean (@NotNull PsiElement target) { return false; } | acceptsTarget |
24,133 | boolean (@NotNull final PsiLiteralExpression expression, final ProcessingContext context) { return PsiUtilEx.isStringOrCharacterLiteral(expression); } | accepts |
24,134 | boolean (@NotNull PsiElement target) { return target instanceof PsiLiteral; } | acceptsTarget |
24,135 | boolean () { return true; } | isSoft |
24,136 | PsiElement () { final Set<String> values = getEnumValues(); return values != null ? values.contains(getValue()) ? myValue : null : null; } | resolve |
24,137 | Set<String> () { return RegExpUtil.getEnumValues(myValue.getProject(), myPattern); } | getEnumValues |
24,138 | Set<String> (String annotationClassName) { GlobalSearchScope allScope = GlobalSearchScope.allScope(myProject); // todo use allScope once Kotlin support becomes fast enough (https://youtrack.jetbrains.com/issue/KT-13734) GlobalSearchScope usageScope = GlobalSearchScope.getScopeRestrictedByFileTypes(allScope, JavaFileTyp... | collectMethodNamesWithLanguage |
24,139 | InjectionCache (Project project) { return project.getService(InjectionCache.class); } | getInstance |
24,140 | Set<String> () { return myAnnoIndex.getValue(); } | getAnnoIndex |
24,141 | Collection<String> () { return myXmlIndex.getValue(); } | getXmlIndex |
24,142 | void (@NotNull MultiHostRegistrar registrar, PsiElement @NotNull ... operands) { if (operands.length == 0) return; boolean hasLiteral = false; InjectedLanguage tempInjectedLanguage = null; PsiFile containingFile = null; TemporaryPlacesRegistry temporaryPlaceRegistry = TemporaryPlacesRegistry.getInstance(myProject); for... | getLanguagesToInject |
24,143 | void (@NotNull MultiHostRegistrar registrar, @NotNull PsiFile containingFile, @Nullable InjectedLanguage tempInjectedLanguage, PsiElement @NotNull [] operands) { Language tempLanguage = tempInjectedLanguage == null ? null : tempInjectedLanguage.getLanguage(); LanguageInjectionSupport injectionSupport = tempLanguage == ... | processOperandsInjection |
24,144 | boolean (String methodName, boolean annoOnly) { if (methodName == null) return false; if (getAnnotatedElementsValue().contains(methodName)) { return true; } return !annoOnly && getXmlAnnotatedElementsValue().contains(methodName); } | areThereInjectionsWithName |
24,145 | void () { PsiElement firstOperand = myOperands[0]; PsiElement topBlock = PsiUtil.getTopLevelEnclosingCodeBlock(firstOperand, null); LocalSearchScope searchScope = new LocalSearchScope(new PsiElement[]{topBlock instanceof PsiCodeBlock ? topBlock : firstOperand.getContainingFile()}, "", true); List<PsiElement> places = n... | processInjections |
24,146 | boolean (@NotNull PsiExpression expression, @NotNull PsiCall psiCallExpression) { PsiExpressionList list = psiCallExpression.getArgumentList(); assert list != null; int index = ArrayUtil.indexOf(list.getExpressions(), expression); String methodName; if (psiCallExpression instanceof PsiMethodCallExpression) { String ref... | visitMethodParameter |
24,147 | boolean (@NotNull PsiElement source, @NotNull PsiMethod method) { if (areThereInjectionsWithName(method.getName(), false)) { process(method, method, -1); } return false; } | visitMethodReturnStatement |
24,148 | void (PsiVariable variable) { if (variable == null) return; if (myConfiguration.getAdvancedConfiguration().getDfaOption() != Configuration.DfaOption.OFF) { ReferencesSearch.search(variable, searchScope).forEach(psiReference -> { PsiElement element = psiReference.getElement(); if (element instanceof PsiExpression refExp... | visitVariableUsages |
24,149 | boolean (@NotNull PsiVariable variable) { if (!visitedVars.add(variable)) return false; visitVariableUsages(variable); PsiElement anchor = !(variable.getFirstChild() instanceof PsiComment) ? variable : variable.getModifierList() != null ? variable.getModifierList() : variable.getTypeElement(); if (anchor != null && !pr... | visitVariable |
24,150 | boolean (@NotNull PsiNameValuePair nameValuePair, @NotNull PsiAnnotation psiAnnotation) { String paramName = nameValuePair.getName(); String methodName = paramName != null ? paramName : PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME; if (areThereInjectionsWithName(methodName, false)) { PsiReference reference = nameValueP... | visitAnnotationParameter |
24,151 | boolean (@NotNull PsiReferenceExpression expression) { if (myConfiguration.getAdvancedConfiguration().getDfaOption() == Configuration.DfaOption.OFF) return true; PsiElement e = expression.resolve(); if (e instanceof PsiVariable) { if (e instanceof PsiParameter p) { PsiElement declarationScope = p.getDeclarationScope();... | visitReference |
24,152 | boolean (@NotNull PsiElement anchor) { Ref<PsiElement> causeRef = Ref.create(); BaseInjection injection = mySupport.findCommentInjection(anchor, causeRef); if (injection != null) { PsiVariable variable = PsiTreeUtil.getParentOfType(anchor, PsiVariable.class); visitVariableUsages(variable); return processCommentInjectio... | processCommentInjection |
24,153 | boolean (PsiElement comment, BaseInjection injection) { processInjectionWithContext(injection, false); return false; } | processCommentInjectionInner |
24,154 | void (PsiModifierListOwner owner, PsiMethod method, int paramIndex) { if (!processAnnotationInjections(owner)) { myShouldStop = true; } for (BaseInjection injection : myConfiguration.getInjections(JavaLanguageInjectionSupport.JAVA_SUPPORT_ID)) { if (injection.acceptsPsiElement(owner)) { if (!processXmlInjections(inject... | process |
24,155 | boolean (PsiModifierListOwner annoElement) { if (annoElement instanceof PsiParameter) { PsiElement scope = ((PsiParameter)annoElement).getDeclarationScope(); if (scope instanceof PsiMethod && !areThereInjectionsWithName(((PsiNamedElement)scope).getName(), true)) { return true; } } PsiAnnotation[] annotations = Annotati... | processAnnotationInjections |
24,156 | boolean (PsiModifierListOwner owner, PsiAnnotation[] annotations) { String id = AnnotationUtilEx.calcAnnotationValue(annotations, "value"); String prefix = AnnotationUtilEx.calcAnnotationValue(annotations, "prefix"); String suffix = AnnotationUtilEx.calcAnnotationValue(annotations, "suffix"); BaseInjection injection = ... | processAnnotationInjectionInner |
24,157 | boolean (BaseInjection injection, PsiModifierListOwner owner, PsiMethod method, int paramIndex) { processInjectionWithContext(injection, true); return !injection.isTerminal(); } | processXmlInjections |
24,158 | List<TextRange> (PsiLanguageInjectionHost host) { if (!(host instanceof PsiLiteralExpression literalExpression)) { return null; } if (!literalExpression.isTextBlock()) { return null; } final TextRange textRange = ElementManipulators.getValueTextRange(host); final int indent = PsiLiteralUtil.getTextBlockIndent(literalEx... | getTextBlockInjectedArea |
24,159 | boolean (Language language) { return LanguageParserDefinitions.INSTANCE.forLanguage(language) == null && ReferenceInjector.findById(language.getID()) != null; } | isReferenceInject |
24,160 | boolean (String methodName, boolean annoOnly) { return true; } | areThereInjectionsWithName |
24,161 | LanguageInjectionSupport () { return mySupport; } | getLanguageInjectionSupport |
24,162 | boolean (PsiExpression refExpression) { PsiElement parent = refExpression.getParent(); if (parent instanceof PsiAssignmentExpression assignmentExpression) { IElementType operation = assignmentExpression.getOperationTokenType(); if (assignmentExpression.getLExpression() == refExpression && JavaTokenType.PLUSEQ.equals(op... | checkUnparsableReference |
24,163 | Collection<String> () { // note: external annotations not supported return InjectionCache.getInstance(myProject).getAnnoIndex(); } | getAnnotatedElementsValue |
24,164 | Collection<String> () { return InjectionCache.getInstance(myProject).getXmlIndex(); } | getXmlAnnotatedElementsValue |
24,165 | String (Project project) { return Configuration.getProjectInstance(project).getAdvancedConfiguration().getLanguageAnnotationClass(); } | getAnnotationName |
24,166 | boolean (PsiType type) { return type == null || !PsiUtilEx.isStringOrStringArray(type); } | isTypeApplicable |
24,167 | String () { return IntelliLangBundle.message("inspection.message.language.injection.only.applicable.to.elements.type.string"); } | getDescriptionTemplate |
24,168 | PsiElementVisitor (@NotNull final ProblemsHolder holder, boolean isOnTheFly) { return new JavaElementVisitor() { final String annotationName = Configuration.getProjectInstance(holder.getProject()).getAdvancedConfiguration().getLanguageAnnotationClass(); @Override public void visitNameValuePair(@NotNull PsiNameValuePair... | buildVisitor |
24,169 | void (@NotNull PsiNameValuePair valuePair) { final PsiAnnotation annotation = PsiTreeUtil.getParentOfType(valuePair, PsiAnnotation.class); if (annotation != null) { final String qualifiedName = annotation.getQualifiedName(); if (annotationName.equals(qualifiedName)) { final String name = valuePair.getName(); if (name =... | visitNameValuePair |
24,170 | OptPane () { return pane( checkbox("CHECK_NON_ANNOTATED_REFERENCES", IntelliLangBundle.message("flag.usages.of.non.annotated.elements")) .description(HtmlChunk.text(IntelliLangBundle.message("flag.usages.of.non.annotated.elements.description"))) ); } | getOptionsPane |
24,171 | PsiElementVisitor (@NotNull final ProblemsHolder holder, boolean isOnTheFly) { return new JavaElementVisitor() { final Pair<String, ? extends Set<String>> annotationName = Configuration.getProjectInstance(holder.getProject()).getAdvancedConfiguration().getLanguageAnnotationPair(); @Override public void visitExpression(... | buildVisitor |
24,172 | void (@NotNull PsiExpression expression) { checkExpression(expression, holder, annotationName); } | visitExpression |
24,173 | void (@NotNull PsiReferenceExpression expression) { if (expression.getParent() instanceof PsiMethodCallExpression) return; final PsiElement element = expression.resolve(); if (!(element instanceof PsiModifierListOwner)) { return; } checkExpression(expression, holder, annotationName); } | visitReferenceExpression |
24,174 | String () { return myClassName; } | getClassName |
24,175 | void (@NotNull String className) { myClassName = className; } | setClassName |
24,176 | void (final Collection<? extends MethodInfo> newInfos) { myParameterMap.clear(); for (MethodInfo methodInfo : newInfos) { myParameterMap.put(methodInfo.getMethodSignature(), methodInfo); } } | setMethodInfos |
24,177 | Collection<MethodInfo> () { return myParameterMap.values(); } | getMethodInfos |
24,178 | MethodParameterInjection (@NotNull BaseInjection o) { super.copyFrom(o); if (o instanceof MethodParameterInjection other) { myClassName = other.getClassName(); myParameterMap.clear(); for (MethodInfo info : other.myParameterMap.values()) { myParameterMap.put(info.methodSignature, info.copy()); } } return this; } | copyFrom |
24,179 | void (Element e) { if (e.getAttribute("injector-id") == null) { setClassName(JDOMExternalizer.readString(e, "CLASS")); //setApplyInHierarchy(JDOMExternalizer.readBoolean(e, "APPLY_IN_HIERARCHY")); readOldFormat(e); final Map<String, String> map = new HashMap<>(); JDOMExternalizer.readMap(e, map, null, "SIGNATURES"); fo... | readExternalImpl |
24,180 | void (final Element e) { final JDOMExternalizableStringList list = new JDOMExternalizableStringList(); try { list.readExternal(e); } catch (IllegalDataException ignored) { } if (list.isEmpty()) return; final boolean[] selection = new boolean[list.size()]; for (int i = 0; i < list.size(); i++) { selection[i] = Boolean.p... | readOldFormat |
24,181 | MethodParameterInjection () { return new MethodParameterInjection().copyFrom(this); } | copy |
24,182 | void () { final PatternCompiler<PsiElement> compiler = getCompiler(); List<String> patternString = getPatternString(this); InjectionPlace[] places = InjectionPlace.ARRAY_FACTORY.create(patternString.size()); for (int i = 0, patternStringSize = patternString.size(); i < patternStringSize; i++) { String text = patternStr... | generatePlaces |
24,183 | boolean (Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; if (!super.equals(o)) return false; final MethodParameterInjection that = (MethodParameterInjection)o; if (!myClassName.equals(that.myClassName)) return false; if (!myParameterMap.equals(that.myParameterMap)) ret... | equals |
24,184 | int () { int result = super.hashCode(); result = 31 * result + myClassName.hashCode(); result = 31 * result + myParameterMap.hashCode(); return result; } | hashCode |
24,185 | String () { final String className = getClassName(); if (StringUtil.isEmpty(className)) return IntelliLangBundle.message("method.param.injection.unnamed.placeholder"); MethodInfo singleInfo = null; for (MethodInfo info : myParameterMap.values()) { if (info.isEnabled()) { if (singleInfo == null) { singleInfo = info; } e... | getDisplayName |
24,186 | String (final String signature, final boolean parameterNames) { @NonNls final StringBuilder sb = new StringBuilder(); final StringTokenizer st = new StringTokenizer(signature, "(,)"); for (int i = 0; st.hasMoreTokens(); i++) { final String token = st.nextToken().trim(); if (i > 1) sb.append(", "); final int idx; if (i ... | fixSignature |
24,187 | String (@NotNull PsiMethod method) { return PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_PARAMETERS, PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.SHOW_FQ_CLASS_NAMES | PsiFormatUtil.SHOW_RAW_TYPE); } | buildSignature |
24,188 | MethodInfo (final PsiMethod method) { final String signature = buildSignature(method); return new MethodInfo(signature, new boolean[method.getParameterList().getParametersCount()], false); } | createMethodInfo |
24,189 | boolean (@Nullable final PsiType type, final Project project) { if (type == null) return false; if (type instanceof PsiPrimitiveType) return false; if (project.isDefault()) { @NonNls final String text = type.getPresentableText(); return text.equals("java.lang.String") || text.equals("java.lang.String...") || text.equal... | isInjectable |
24,190 | PsiMethod (final Project project, final String signature) { if (StringUtil.isEmpty(signature)) return null; try { return JavaPsiFacade.getInstance(project).getElementFactory(). createMethodFromText("void " + fixSignature(signature, true) + "{}", null); } catch (IncorrectOperationException e) { // something wrong } retu... | makeMethod |
24,191 | String (final String signature) { @NonNls final StringBuilder sb = new StringBuilder(); final StringTokenizer st = new StringTokenizer(signature, "(,)"); for (int i = 0; st.hasMoreTokens(); i++) { final String token = st.nextToken().trim(); if (i > 1) sb.append(", "); final int idx; if (i == 0) { // nothing } else { sb... | getParameterTypesString |
24,192 | String (final String methodName, final String parametersStrings, final int parameterIndex, final String className) { final StringBuilder sb = new StringBuilder(); if (parameterIndex >= 0) { sb.append("psiParameter().ofMethod(").append(parameterIndex).append(", "); } sb.append("psiMethod().withName(\"").append(methodNam... | getPatternStringForJavaPlace |
24,193 | String () { return methodSignature; } | getMethodSignature |
24,194 | String () { return methodName; } | getMethodName |
24,195 | boolean () { return returnFlag; } | isReturnFlag |
24,196 | void (final boolean returnFlag) { this.returnFlag = returnFlag; } | setReturnFlag |
24,197 | boolean () { if (returnFlag) return true; for (boolean b : paramFlags) { if (b) return true; } return false; } | isEnabled |
24,198 | String (final String methodSignature) { final String s = StringUtil.split(methodSignature, "(").get(0); return s.length() == 0 ? "<none>" : s; } | calcMethodName |
24,199 | String () { final StringBuilder result = new StringBuilder(); result.append(returnFlag).append(':'); boolean first = true; for (boolean b : paramFlags) { if (first) first = false; else result.append(','); result.append(b); } return result.toString(); } | getFlagsString |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.