Package org.eclipse.jdt.internal.compiler.ast

Examples of org.eclipse.jdt.internal.compiler.ast.Argument

474
475
476
477
478
479
480
481
482
483
484
  TypeBinding [] inheritedParameterTypes = inheritedMethod.parameters;
  Argument[] arguments = methodDecl.arguments;
  for (int j = 0, size = currentMethod.parameters.length; j < size; j++) {
    TypeBinding parameterType = parameterTypes[j];
    TypeBinding inheritedParameterType = inheritedParameterTypes[j];
    Argument arg = arguments[j];
    if (parameterType.leafComponentType().isRawType()) {
      if (inheritedParameterType.leafComponentType().isRawType()) {
        arg.binding.tagBits |= TagBits.ForcedToBeRawType;
      } else {
        if (compilerOptions.getSeverity(CompilerOptions.RawTypeReference) != ProblemSeverities.Ignore
View Full Code Here
192
193
194
195
196
197
198
199
200
201
202
      TypeReference typeReference = createTypeReference(argumentTypeName);
      if (typeReference == null) return null;
      if (isVarargs && i == argumentCount-1) {
        typeReference.bits |= ASTNode.IsVarArgs;
      }
      methodDeclaration.arguments[i] = new Argument(
        argumentNames[i].toCharArray(),
        0,
        typeReference,
        ClassFileConstants.AccDefault);
      // do not care whether was final or not
View Full Code Here
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
              int argumentCount = arguments.length;
              if (parameterCount > argumentCount) { // synthetics prefixed
                int redShift = parameterCount - argumentCount;
                System.arraycopy(arguments, 0, arguments = new Argument[parameterCount], redShift, argumentCount);
                for (int i = 0; i < redShift; i++)
                  arguments[i] = new Argument(CharOperation.NO_CHAR, 0, null, 0);
              }
              attributesNumber += generateRuntimeAnnotationsForParameters(arguments);
            }
          } 
        }
View Full Code Here
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
    final int INVISIBLE_INDEX = 1;
    int invisibleParametersAnnotationsCounter = 0;
    int visibleParametersAnnotationsCounter = 0;
    int[][] annotationsCounters = new int[argumentsLength][2];
    for (int i = 0; i < argumentsLength; i++) {
      Argument argument = arguments[i];
      Annotation[] annotations = argument.annotations;
      if (annotations != null) {
        for (int j = 0, max2 = annotations.length; j < max2; j++) {
          Annotation annotation;
          if ((annotation = annotations[j].getPersistibleAnnotation()) == null) continue; // already packaged into container.
          long annotationMask = annotation.resolvedType != null ? annotation.resolvedType.getAnnotationTagBits() & TagBits.AnnotationTargetMASK : 0;
          if (annotationMask != 0 && (annotationMask & TagBits.AnnotationForParameter) == 0) continue;
          if (annotation.isRuntimeInvisible()) {
            annotationsCounters[i][INVISIBLE_INDEX]++;
            invisibleParametersAnnotationsCounter++;
          } else if (annotation.isRuntimeVisible()) {
            annotationsCounters[i][VISIBLE_INDEX]++;
            visibleParametersAnnotationsCounter++;
          }
        }
      }
    }
    int attributesNumber = 0;
    int annotationAttributeOffset = this.contentsOffset;
    if (invisibleParametersAnnotationsCounter != 0) {
      int globalCounter = 0;
      if (this.contentsOffset + 7 >= this.contents.length) {
        resizeContents(7);
      }
      int attributeNameIndex =
        this.constantPool.literalIndex(AttributeNamesConstants.RuntimeInvisibleParameterAnnotationsName);
      this.contents[this.contentsOffset++] = (byte) (attributeNameIndex >> 8);
      this.contents[this.contentsOffset++] = (byte) attributeNameIndex;
      int attributeLengthOffset = this.contentsOffset;
      this.contentsOffset += 4; // leave space for the attribute length

      this.contents[this.contentsOffset++] = (byte) argumentsLength;
      for (int i = 0; i < argumentsLength; i++) {
        if (this.contentsOffset + 2 >= this.contents.length) {
          resizeContents(2);
        }
        if (invisibleParametersAnnotationsCounter == 0) {
          this.contents[this.contentsOffset++] = (byte) 0;
          this.contents[this.contentsOffset++] = (byte) 0;
        } else {
          final int numberOfInvisibleAnnotations = annotationsCounters[i][INVISIBLE_INDEX];
          int invisibleAnnotationsOffset = this.contentsOffset;
          // leave space for number of annotations
          this.contentsOffset += 2;
          int counter = 0;
          if (numberOfInvisibleAnnotations != 0) {
            Argument argument = arguments[i];
            Annotation[] annotations = argument.annotations;
            for (int j = 0, max = annotations.length; j < max; j++) {
              Annotation annotation;
              if ((annotation = annotations[j].getPersistibleAnnotation()) == null) continue; // already packaged into container.
              long annotationMask = annotation.resolvedType != null ? annotation.resolvedType.getAnnotationTagBits() & TagBits.AnnotationTargetMASK : 0;
              if (annotationMask != 0 && (annotationMask & TagBits.AnnotationForParameter) == 0) continue;
              if (annotation.isRuntimeInvisible()) {
                int currentAnnotationOffset = this.contentsOffset;
                generateAnnotation(annotation, currentAnnotationOffset);
                if (this.contentsOffset != currentAnnotationOffset) {
                  counter++;
                  globalCounter++;
                }
                invisibleParametersAnnotationsCounter--;
              }
            }
          }
          this.contents[invisibleAnnotationsOffset++] = (byte) (counter >> 8);
          this.contents[invisibleAnnotationsOffset] = (byte) counter;
        }
      }
      if (globalCounter != 0) {
        int attributeLength = this.contentsOffset - attributeLengthOffset - 4;
        this.contents[attributeLengthOffset++] = (byte) (attributeLength >> 24);
        this.contents[attributeLengthOffset++] = (byte) (attributeLength >> 16);
        this.contents[attributeLengthOffset++] = (byte) (attributeLength >> 8);
        this.contents[attributeLengthOffset++] = (byte) attributeLength;
        attributesNumber++;
      } else {
        // if globalCounter is 0, this means that the code generation for all visible annotations failed
        this.contentsOffset = annotationAttributeOffset;
      }
    }
    if (visibleParametersAnnotationsCounter != 0) {
      int globalCounter = 0;
      if (this.contentsOffset + 7 >= this.contents.length) {
        resizeContents(7);
      }
      int attributeNameIndex =
        this.constantPool.literalIndex(AttributeNamesConstants.RuntimeVisibleParameterAnnotationsName);
      this.contents[this.contentsOffset++] = (byte) (attributeNameIndex >> 8);
      this.contents[this.contentsOffset++] = (byte) attributeNameIndex;
      int attributeLengthOffset = this.contentsOffset;
      this.contentsOffset += 4; // leave space for the attribute length

      this.contents[this.contentsOffset++] = (byte) argumentsLength;
      for (int i = 0; i < argumentsLength; i++) {
        if (this.contentsOffset + 2 >= this.contents.length) {
          resizeContents(2);
        }
        if (visibleParametersAnnotationsCounter == 0) {
          this.contents[this.contentsOffset++] = (byte) 0;
          this.contents[this.contentsOffset++] = (byte) 0;
        } else {
          final int numberOfVisibleAnnotations = annotationsCounters[i][VISIBLE_INDEX];
          int visibleAnnotationsOffset = this.contentsOffset;
          // leave space for number of annotations
          this.contentsOffset += 2;
          int counter = 0;
          if (numberOfVisibleAnnotations != 0) {
            Argument argument = arguments[i];
            Annotation[] annotations = argument.annotations;
            for (int j = 0, max = annotations.length; j < max; j++) {
              Annotation annotation;
              if ((annotation = annotations[j].getPersistibleAnnotation()) == null) continue; // already packaged into container.
              long annotationMask = annotation.resolvedType != null ? annotation.resolvedType.getAnnotationTagBits() & TagBits.AnnotationTargetMASK : 0;
View Full Code Here
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
      } else if (binding.sourceLambda() != null) { // SyntheticMethodBinding, purpose : LambdaMethod.
        arguments = binding.sourceLambda().arguments;
      }
      for (int i = 0, max = targetParameters.length, argumentsLength = arguments != null ? arguments.length : 0; i < max; i++) {
        if (argumentsLength > i && arguments[i] != null) {
          Argument argument = arguments[i];
          length = writeArgumentName(argument.name, argument.binding.modifiers, length);
        } else {
          length = writeArgumentName(null, ClassFileConstants.AccSynthetic, length);
        }
      }
View Full Code Here
109
110
111
112
113
114
115
116
117
118
119
  int argumentLength = arguments.length;
  char[][] argumentTypes = new char[argumentLength][];
  char[][] argumentNames = new char[argumentLength][];
  ParameterInfo[] parameterInfos = new ParameterInfo[argumentLength];
  for (int i = 0; i < argumentLength; i++) {
    Argument argument = arguments[i];
    argumentTypes[i] = CharOperation.concatWith(argument.type.getParameterizedTypeName(), '.');
    char[] name = argument.name;
    argumentNames[i] = name;
    ParameterInfo parameterInfo = new ParameterInfo();
    parameterInfo.declarationStart = argument.declarationSourceStart;
View Full Code Here
685
686
687
688
689
690
691
692
693
694
695
    if (this.declaringClass instanceof SourceTypeBinding) {
      SourceTypeBinding sourceType = (SourceTypeBinding) this.declaringClass;
      if (sourceType.scope != null) {
        AbstractMethodDeclaration methodDecl = sourceType.scope.referenceType().declarationOf(this);
        for (int i = 0; i < length; i++) {
          Argument argument = methodDecl.arguments[i];
          if (argument.annotations != null) {
            ASTNode.resolveAnnotations(methodDecl.scope, argument.annotations, argument.binding);
            allParameterAnnotations[i] = argument.binding.getAnnotations();
          } else {
            allParameterAnnotations[i] = Binding.NO_ANNOTATIONS;
View Full Code Here
135
136
137
138
139
140
141
142
143
144
145
          }
        }
        for (int i=0; i<paramLen; i++) {
          info = inheritedNonNullnessInfos[i+1];
          if (!info.complained && info.inheritedNonNullness != null) {
            Argument currentArg = srcMethod == null ? null : srcMethod.arguments[i];
            if (sourceLevel < ClassFileConstants.JDK1_8)
              recordArgNonNullness(currentMethod, paramLen, i, currentArg, info.inheritedNonNullness);
            else
              recordArgNonNullness18(currentMethod, i, currentArg, info.inheritedNonNullness, scope.environment());
          }
View Full Code Here
319
320
321
322
323
324
325
326
327
328
329
      length = currentMethod.parameterNonNullness.length;

    for (int i = 0; i < length; i++) {
      if (currentMethod.parameters[i].isBaseType()) continue;

      Argument currentArgument = currentArguments == null
                    ? null : currentArguments[i];
      Boolean inheritedNonNullNess = getParameterNonNullness(inheritedMethod, i, useTypeAnnotations);
      Boolean currentNonNullNess = getParameterNonNullness(currentMethod, i, useTypeAnnotations);

      if (currentNonNullNess == null) {
View Full Code Here
455
456
457
458
459
460
461
462
463
464
465
private LocalVariable[] acceptMethodParameters(Argument[] arguments, JavaElement methodHandle, MethodInfo methodInfo) {
  if (arguments == null) return null;
  LocalVariable[] result = new LocalVariable[arguments.length];
  Annotation[][] paramAnnotations = new Annotation[arguments.length][];
  for(int i = 0; i < arguments.length; i++) {
    Argument argument = arguments[i];
    AnnotatableInfo localVarInfo = new AnnotatableInfo();
    localVarInfo.setSourceRangeStart(argument.declarationSourceStart);
    localVarInfo.setSourceRangeEnd(argument.declarationSourceStart);
    localVarInfo.setNameSourceStart(argument.sourceStart);
    localVarInfo.setNameSourceEnd(argument.sourceEnd);
View Full Code Here
TOP

Related Classes of org.eclipse.jdt.internal.compiler.ast.Argument

  • com.google.gwt.dev.javac.TypeOracleMediator
  • com.google.gwt.dev.jdt.FindJsniRefVisitor
  • com.google.gwt.dev.jdt.TypeOracleBuilder
  • com.google.gwt.dev.jjs.impl.GwtAstBuilder$AstVisitor
  • org.eclipse.jdt.internal.codeassist.CompletionElementNotifier
  • org.eclipse.jdt.internal.codeassist.select.SelectionParser
  • org.eclipse.jdt.internal.compiler.ClassFile
  • org.eclipse.jdt.internal.compiler.lookup.ImplicitNullAnnotationVerifier
  • org.eclipse.jdt.internal.compiler.lookup.MethodBinding
  • org.eclipse.jdt.internal.compiler.lookup.MethodVerifier15
    • 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.