private MethodDeclaration findAfter( char[] startWith, Scope s, int from, int to, int maxLineCount, boolean outsideEnclosingBlock, char[][] discouragedNames, UnresolvedReferenceNameRequestor nameRequestor) { this.requestor = nameRequestor; // reinitialize completion scanner to be usable as a normal scanner this.completionScanner.cursorLocation = 0; if (!outsideEnclosingBlock) { // compute location of the end of the current block this.completionScanner.resetTo(from + 1, to); this.completionScanner.jumpOverBlock(); to = this.completionScanner.startPosition - 1; } int maxEnd = this.completionScanner.getLineEnd( Util.getLineNumber( from, this.completionScanner.lineEnds, 0, this.completionScanner.linePtr) + maxLineCount); int end; if (maxEnd < 0) { end = to; } else { end = maxEnd < to ? maxEnd : to; } this.parser.startRecordingIdentifiers(from, end); MethodDeclaration fakeMethod = this.parser.parseSomeStatements( from, end, outsideEnclosingBlock ? FAKE_BLOCKS_COUNT : 0, s.compilationUnitScope().referenceContext); this.parser.stopRecordingIdentifiers(); if (!this.initPotentialNamesTables(discouragedNames)) return null; this.parentsPtr = -1; this.parents = new ASTNode[10]; return fakeMethod; }
private MethodDeclaration findBefore( char[] startWith, Scope s, int from, int recordTo, int parseTo, int maxLineCount, char[][] discouragedNames, UnresolvedReferenceNameRequestor nameRequestor) { this.requestor = nameRequestor; // reinitialize completion scanner to be usable as a normal scanner this.completionScanner.cursorLocation = 0; int minStart = this.completionScanner.getLineStart( Util.getLineNumber( recordTo, this.completionScanner.lineEnds, 0, this.completionScanner.linePtr) - maxLineCount); int start; int fakeBlocksCount; if (minStart <= from) { start = from; fakeBlocksCount = 0; } else { start = minStart; fakeBlocksCount = FAKE_BLOCKS_COUNT; } this.parser.startRecordingIdentifiers(start, recordTo); MethodDeclaration fakeMethod = this.parser.parseSomeStatements( start, parseTo, fakeBlocksCount, s.compilationUnitScope().referenceContext); this.parser.stopRecordingIdentifiers(); if (!this.initPotentialNamesTables(discouragedNames)) return null; this.parentsPtr = -1; this.parents = new ASTNode[10]; return fakeMethod; }
public void resolve(MethodScope initializationScope) { // the two <constant = Constant.NotAConstant> could be regrouped into // a single line but it is clearer to have two lines while the reason of their // existence is not at all the same. See comment for the second one. // -------------------------------------------------------- if ((this.bits & ASTNode.HasBeenResolved) != 0) return; if (this.binding == null || !this.binding.isValidBinding()) return; this.bits |= ASTNode.HasBeenResolved; // check if field is hiding some variable - issue is that field binding already got inserted in // scope // thus must lookup separately in super type and outer context ClassScope classScope = initializationScope.enclosingClassScope(); if (classScope != null) { checkHiding: { SourceTypeBinding declaringType = classScope.enclosingSourceType(); checkHidingSuperField: { if (declaringType.superclass == null) break checkHidingSuperField; Binding existingVariable = classScope.findField( declaringType.superclass, this.name, this, false /*do not resolve hidden field*/); if (existingVariable == null) break checkHidingSuperField; // keep checking outer scenario if (!existingVariable.isValidBinding()) break checkHidingSuperField; // keep checking outer scenario if (existingVariable instanceof FieldBinding) { FieldBinding existingField = (FieldBinding) existingVariable; if (existingField.original() == this.binding) break checkHidingSuperField; // keep checking outer scenario } // collision with supertype field initializationScope.problemReporter().fieldHiding(this, existingVariable); break checkHiding; // already found a matching field } // only corner case is: lookup of outer field through static declaringType, which isn't // detected by #getBinding as lookup starts // from outer scope. Subsequent static contexts are detected for free. Scope outerScope = classScope.parent; if (outerScope.kind == Scope.COMPILATION_UNIT_SCOPE) break checkHiding; Binding existingVariable = outerScope.getBinding( this.name, Binding.VARIABLE, this, false /*do not resolve hidden field*/); if (existingVariable == null) break checkHiding; if (!existingVariable.isValidBinding()) break checkHiding; if (existingVariable == this.binding) break checkHiding; if (existingVariable instanceof FieldBinding) { FieldBinding existingField = (FieldBinding) existingVariable; if (existingField.original() == this.binding) break checkHiding; if (!existingField.isStatic() && declaringType.isStatic()) break checkHiding; } // collision with outer field or local variable initializationScope.problemReporter().fieldHiding(this, existingVariable); } } if (this.type != null) { // enum constants have no declared type this.type.resolvedType = this.binding.type; // update binding for type reference } FieldBinding previousField = initializationScope.initializedField; int previousFieldID = initializationScope.lastVisibleFieldID; try { initializationScope.initializedField = this.binding; initializationScope.lastVisibleFieldID = this.binding.id; // resolveAnnotations(initializationScope, this.annotations, this.binding); // the resolution of the initialization hasn't been done if (this.initialization != null) { TypeBinding fieldType = this.binding.type; TypeBinding initializationType; this.initialization.setExpectedType( fieldType); // needed in case of generic method invocation if (this.initialization instanceof ArrayInitializer) { if ((initializationType = this.initialization.resolveTypeExpecting(initializationScope, fieldType)) != null) { ((ArrayInitializer) this.initialization).binding = (ArrayBinding) initializationType; } } else if ((initializationType = this.initialization.resolveType(initializationScope)) != null) { if (fieldType != initializationType) // must call before computeConversion() and typeMismatchError() initializationScope .compilationUnitScope() .recordTypeConversion(fieldType, initializationType); if (this.initialization.isConstantValueOfTypeAssignableToType( initializationType, fieldType) || (fieldType.isBaseType() && BaseTypeBinding.isWidening(fieldType.id, initializationType.id)) || initializationType.isCompatibleWith(fieldType)) { } else if (initializationScope.isBoxingCompatibleWith(initializationType, fieldType) || (initializationType.isBaseType() // narrowing then boxing ? && initializationScope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5 // autoboxing && !fieldType.isBaseType() && initialization.isConstantValueOfTypeAssignableToType( initializationType, initializationScope.environment().computeBoxingType(fieldType)))) { } else { initializationScope .problemReporter() .typeMismatchError(initializationType, fieldType, this); } } // check for assignment with no effect if (this.binding == Assignment.getDirectBinding(this.initialization)) { initializationScope.problemReporter().assignmentHasNoEffect(this, this.name); } } // Resolve Javadoc comment if one is present if (this.javadoc != null) { /* if (classScope != null) { this.javadoc.resolve(classScope); } */ this.javadoc.resolve(initializationScope); } else if (this.binding.declaringClass != null && !this.binding.declaringClass.isLocalType()) { initializationScope .problemReporter() .javadocMissing(this.sourceStart, this.sourceEnd, this.binding.modifiers); } } finally { initializationScope.initializedField = previousField; initializationScope.lastVisibleFieldID = previousFieldID; } }