Package org.eclipse.jdt.internal.compiler.lookup

Examples of org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding

826
827
828
829
830
831
832
833
834
835
836
  public ITypeBinding[] getTypeArguments() {
    if (this.typeArguments != null) {
      return this.typeArguments;
    }
    if (this.binding.isParameterizedTypeWithActualArguments()) {
      ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) this.binding;
      final org.eclipse.jdt.internal.compiler.lookup.TypeBinding[] arguments = parameterizedTypeBinding.arguments;
      int argumentsLength = arguments.length;
      ITypeBinding[] newTypeArguments = new ITypeBinding[argumentsLength];
      for (int i = 0; i < argumentsLength; i++) {
        ITypeBinding typeBinding = this.resolver.getTypeBinding(arguments[i]);
View Full Code Here
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
    if (isClass() || isInterface() || isEnum()) {
      ReferenceBinding referenceBinding = (ReferenceBinding) this.binding;
      if (referenceBinding.isRawType()) {
        return !((RawTypeBinding) referenceBinding).genericType().isBinaryBinding();
      } else if (referenceBinding.isParameterizedType()) {
        ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) referenceBinding;
        org.eclipse.jdt.internal.compiler.lookup.TypeBinding erasure = parameterizedTypeBinding.erasure();
        if (erasure instanceof ReferenceBinding) {
          return !((ReferenceBinding) erasure).isBinaryBinding();
        }
        return false;
      } else {
View Full Code Here
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
    TypeBinding[] typeBindings = parameterizedMethodBinding.isRaw ? null : parameterizedMethodBinding.typeArguments;
    updateMatch(typeBindings, locator, this.pattern.constructorArguments, this.pattern.hasConstructorParameters());

    // Update match regarding declaring class type arguments
    if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
      ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
      if (!this.pattern.hasTypeArguments() && this.pattern.hasConstructorArguments() || parameterizedBinding.isParameterizedWithOwnVariables()) {
        // special case for constructor pattern which defines arguments but no type
        // in this case, we only use refined accuracy for constructor
      } else if (this.pattern.hasTypeArguments() && !this.pattern.hasConstructorArguments()) {
        // special case for constructor pattern which defines no constructor arguments but has type ones
        // in this case, we do not use refined accuracy
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      } else {
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      }
    } else if (this.pattern.hasTypeArguments()) {
      this.match.setRule(SearchPattern.R_ERASURE_MATCH);
    }

    // Update match regarding constructor parameters
    // TODO ? (frederic)
  } else if (constructorBinding instanceof ParameterizedMethodBinding) {
    // Update match regarding declaring class type arguments
    if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
      ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
      if (!this.pattern.hasTypeArguments() && this.pattern.hasConstructorArguments()) {
        // special case for constructor pattern which defines arguments but no type
        updateMatch(parameterizedBinding, new char[][][] {this.pattern.constructorArguments}, this.pattern.hasTypeParameters(), 0, locator);
      } else if (!parameterizedBinding.isParameterizedWithOwnVariables()) {
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      }
    } else if (this.pattern.hasTypeArguments()) {
      this.match.setRule(SearchPattern.R_ERASURE_MATCH);
    }
View Full Code Here
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
      return;
    }
    classFile.visitedTypes.add(typeBinding);
    if (typeBinding.isParameterizedType()
        && ((typeBinding.tagBits & TagBits.ContainsNestedTypeReferences) != 0)) {
      ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) typeBinding;
      ReferenceBinding genericType = parameterizedTypeBinding.genericType();
      if ((genericType.tagBits & TagBits.ContainsNestedTypeReferences) != 0) {
        recordNestedType(classFile, genericType);
      }
      TypeBinding[] arguments = parameterizedTypeBinding.arguments;
      if (arguments != null) {
View Full Code Here
77
78
79
80
81
82
83
84
85
86
87
   */
  @Override
  public List<? extends TypeMirror> getTypeArguments() {
    ReferenceBinding binding = (ReferenceBinding)_binding;
    if (binding.isParameterizedType()) {
      ParameterizedTypeBinding ptb = (ParameterizedTypeBinding)_binding;
      TypeBinding[] arguments = ptb.arguments;
      int length = arguments == null ? 0 : arguments.length;
      if (length == 0) return Collections.emptyList();
      List<TypeMirror> args = new ArrayList<TypeMirror>(length);
      for (TypeBinding arg : arguments) {
View Full Code Here
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
                this.bits |= ASTNode.UnsafeCast;
                return true;
              }
              // [JLS 5.5] S has no subtype X != T, such that |X| == |T|
              // if I2<T,U> extends I1<T>, then cast from I1<T> to I2<T,U> is unchecked
              ParameterizedTypeBinding paramCastType = (ParameterizedTypeBinding) castType;
              ParameterizedTypeBinding paramMatch = (ParameterizedTypeBinding) match;
              // easy case if less parameters on match
              TypeBinding[] castArguments = paramCastType.arguments;
              int length = castArguments == null ? 0 : castArguments.length;
              if (paramMatch.arguments == null || length > paramMatch.arguments.length) {
                this.bits |= ASTNode.UnsafeCast;
              } else if ((paramCastType.tagBits & (TagBits.HasDirectWildcard|TagBits.HasTypeVariable)) != 0) {
                // verify alternate cast type, substituting different type arguments
                nextAlternateArgument: for (int i = 0; i < length; i++) {
                  switch (castArguments[i].kind()) {
                    case Binding.WILDCARD_TYPE :
                    case Binding.TYPE_PARAMETER :
                      break; // check substituting with other
                    default:
                      continue nextAlternateArgument; // no alternative possible
                  }
                  TypeBinding[] alternateArguments;
                  // need to clone for each iteration to avoid env paramtype cache interference
                  System.arraycopy(paramCastType.arguments, 0, alternateArguments = new TypeBinding[length], 0, length);
                  alternateArguments[i] = scope.getJavaLangObject();
                  LookupEnvironment environment = scope.environment();
                  ParameterizedTypeBinding alternateCastType = environment.createParameterizedType((ReferenceBinding)castType.erasure(), alternateArguments, castType.enclosingType());
                  if (alternateCastType.findSuperTypeOriginatingFrom(expressionType) == match) {
                    this.bits |= ASTNode.UnsafeCast;
                    break;
                  }
                }
              }
View Full Code Here
53
54
55
56
57
58
59
60
61
62
63
  @Override
  public List<? extends TypeMirror> getTypeArguments() {
    ReferenceBinding binding = (ReferenceBinding)_binding;
    if (binding.isParameterizedType()) {
      ParameterizedTypeBinding ptb = (ParameterizedTypeBinding)_binding;
      TypeBinding[] arguments = ptb.arguments;
      int length = arguments == null ? 0 : arguments.length;
      if (length == 0) return Collections.emptyList();
      List<TypeMirror> args = new ArrayList<TypeMirror>(length);
      for (TypeBinding arg : arguments) {
View Full Code Here
421
422
423
424
425
426
427
428
429
430
431
  }

  private ReferenceBinding findGroundTargetType(BlockScope blockScope, ReferenceBinding targetType, boolean argumentTypesElided) {
    if (!targetType.isValidBinding())
      return null;
    ParameterizedTypeBinding withWildCards = InferenceContext18.parameterizedWithWildcard(targetType);
    if (withWildCards != null) {
      if (!argumentTypesElided)
        return new InferenceContext18(blockScope).inferFunctionalInterfaceParameterization(this, blockScope, withWildCards);
      else
        return findGroundTargetTypeForElidedLambda(blockScope, withWildCards);
View Full Code Here
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
    TypeBinding[] typeBindings = parameterizedMethodBinding.isRaw ? null : parameterizedMethodBinding.typeArguments;
    updateMatch(typeBindings, locator, this.pattern.constructorArguments, this.pattern.hasConstructorParameters());

    // Update match regarding declaring class type arguments
    if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
      ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
      if (!this.pattern.hasTypeArguments() && this.pattern.hasConstructorArguments() || parameterizedBinding.isParameterizedWithOwnVariables()) {
        // special case for constructor pattern which defines arguments but no type
        // in this case, we only use refined accuracy for constructor
      } else if (this.pattern.hasTypeArguments() && !this.pattern.hasConstructorArguments()) {
        // special case for constructor pattern which defines no constructor arguments but has type ones
        // in this case, we do not use refined accuracy
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      } else {
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      }
    } else if (this.pattern.hasTypeArguments()) {
      this.match.setRule(SearchPattern.R_ERASURE_MATCH);
    }

    // Update match regarding constructor parameters
    // TODO ? (frederic)
  } else if (constructorBinding instanceof ParameterizedMethodBinding) {
    // Update match regarding declaring class type arguments
    if (constructorBinding.declaringClass.isParameterizedType() || constructorBinding.declaringClass.isRawType()) {
      ParameterizedTypeBinding parameterizedBinding = (ParameterizedTypeBinding)constructorBinding.declaringClass;
      if (!this.pattern.hasTypeArguments() && this.pattern.hasConstructorArguments()) {
        // special case for constructor pattern which defines arguments but no type
        updateMatch(parameterizedBinding, new char[][][] {this.pattern.constructorArguments}, this.pattern.hasTypeParameters(), 0, locator);
      } else if (!parameterizedBinding.isParameterizedWithOwnVariables()) {
        updateMatch(parameterizedBinding, this.pattern.getTypeArguments(), this.pattern.hasTypeParameters(), 0, locator);
      }
    } else if (this.pattern.hasTypeArguments()) {
      this.match.setRule(SearchPattern.R_ERASURE_MATCH);
    }
View Full Code Here
645
646
647
648
649
650
651
652
653
654
655
656
657
        }
        TypeVariableBinding typeVariableBinding = (TypeVariableBinding) this.binding;
        return new String(typeVariableBinding.sourceName);

      case Binding.PARAMETERIZED_TYPE :
        ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) this.binding;
        buffer = new StringBuffer();
        buffer.append(parameterizedTypeBinding.sourceName());
        ITypeBinding[] tArguments = getTypeArguments();
        final int typeArgumentsLength = tArguments.length;
        if (typeArgumentsLength != 0) {
          buffer.append('<');
          for (int i = 0; i < typeArgumentsLength; i++) {
View Full Code Here
TOP

Related Classes of org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding

  • com.google.gwt.dev.javac.TypeOracleMediator
  • com.google.gwt.dev.jdt.TypeRefVisitor
  • com.google.gwt.dev.jjs.impl.TypeMap
  • org.eclipse.jdt.core.dom.BindingComparator
  • org.eclipse.jdt.core.dom.TypeBinding
  • org.eclipse.jdt.internal.compiler.apt.model.DeclaredTypeImpl
  • org.eclipse.jdt.internal.compiler.apt.model.ErrorTypeImpl
  • org.eclipse.jdt.internal.compiler.ast.CastExpression
  • org.eclipse.jdt.internal.compiler.ast.LambdaExpression
  • org.eclipse.jdt.internal.compiler.impl.CompilerOptions
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.