122     /////////////////// TA Position Builder ///////////////////////

   123     /* TODO: comment out this dead code. Was this unfinished code that was

   124      * supposed to be used somewhere? The tests pass without this.

   125     private static class TAPositionBuilder {

   126         private TypeAnnotation.Position pos = new TypeAnnotation.Position();

   127 

   128         private TAPositionBuilder() { }

   129 

   130         public TypeAnnotation.Position build() { return pos; }

   131 

   132         public static TAPositionBuilder ofType(TypeAnnotation.TargetType type) {

   133             TAPositionBuilder builder = new TAPositionBuilder();

   134             builder.pos.type = type;

   135             return builder;

   136         }

   137 

   138         public TAPositionBuilder atOffset(int offset) {

   139             switch (pos.type) {

   140             // type cast

   141             case TYPECAST:

   142             // instanceof

   143             case INSTANCEOF:

   144             // new expression

   145             case NEW:

   146                 pos.offset = offset;

   147                 break;

   148             default:

   149                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   150             }

   151             return this;

   152         }

   153 

   154         public TAPositionBuilder atLocalPosition(int offset, int length, int index) {

   155             switch (pos.type) {

   156             // local variable

   157             case LOCAL_VARIABLE:

   158                 pos.lvarOffset = new int[] { offset };

   159                 pos.lvarLength = new int[] { length };

   160                 pos.lvarIndex  = new int[] { index  };

   161                 break;

   162             default:

   163                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   164             }

   165             return this;

   166         }

   167 

   168         public TAPositionBuilder atParameterIndex(int index) {

   169             switch (pos.type) {

   170             // type parameters

   171             case CLASS_TYPE_PARAMETER:

   172             case METHOD_TYPE_PARAMETER:

   173             // method parameter

   174             case METHOD_FORMAL_PARAMETER:

   175                 pos.parameter_index = index;

   176                 break;

   177             default:

   178                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   179             }

   180             return this;

   181         }

   182 

   183         public TAPositionBuilder atParamBound(int param, int bound) {

   184             switch (pos.type) {

   185             // type parameters bounds

   186             case CLASS_TYPE_PARAMETER_BOUND:

   187             case METHOD_TYPE_PARAMETER_BOUND:

   188                 pos.parameter_index = param;

   189                 pos.bound_index = bound;

   190                 break;

   191             default:

   192                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   193             }

   194             return this;

   195         }

   196 

   197         public TAPositionBuilder atWildcardPosition(TypeAnnotation.Position pos) {

   198             switch (pos.type) {

   199             // wildcards

   200             case WILDCARD_BOUND:

   201                 pos.wildcard_position = pos;

   202                 break;

   203             default:

   204                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   205             }

   206             return this;

   207         }

   208 

   209         public TAPositionBuilder atTypeIndex(int index) {

   210             switch (pos.type) {

   211             // class extends or implements clauses

   212             case CLASS_EXTENDS:

   213             // throws

   214             case THROWS:

   215                 pos.type_index = index;

   216                 break;

   217             default:

   218                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   219             }

   220             return this;

   221         }

   222 

   223         public TAPositionBuilder atOffsetWithIndex(int offset, int index) {

   224             switch (pos.type) {

   225             // method type argument: wasn't specified

   226             case NEW_TYPE_ARGUMENT:

   227             case METHOD_TYPE_ARGUMENT:

   228                 pos.offset = offset;

   229                 pos.type_index = index;

   230                 break;

   231             default:

   232                 throw new IllegalArgumentException("invalid field for given type: " + pos.type);

   233             }

   234             return this;

   235         }

   236 

   237         public TAPositionBuilder atGenericLocation(Integer ...loc) {

   238             pos.location = Arrays.asList(loc);

   239             pos.type = pos.type.getGenericComplement();

   240             return this;

   241         }

   242     }*/

   243 

   309             // TODO: you currently get an exception if the test case does not use all necessary

   310             // annotation attributes, e.g. forgetting the offset for a local variable.

   311             // It would be nicer to give an understandable warning instead.