Example usage for org.eclipse.jdt.internal.compiler.lookup TypeIds T_JavaLangString

List of usage examples for org.eclipse.jdt.internal.compiler.lookup TypeIds T_JavaLangString

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.lookup TypeIds T_JavaLangString.

Prototype

int T_JavaLangString

To view the source code for org.eclipse.jdt.internal.compiler.lookup TypeIds T_JavaLangString.

Click Source Link

Usage

From source file:com.codenvy.ide.ext.java.server.internal.core.Member.java

License:Open Source License

/**
 * Converts a field constant from the compiler's representation
 * to the Java Model constant representation (Number or String).
 *//*w w w . j a  v  a2 s .co  m*/
protected static Object convertConstant(Constant constant) {
    if (constant == null)
        return null;
    if (constant == Constant.NotAConstant) {
        return null;
    }
    switch (constant.typeID()) {
    case TypeIds.T_boolean:
        return constant.booleanValue() ? Boolean.TRUE : Boolean.FALSE;
    case TypeIds.T_byte:
        return new Byte(constant.byteValue());
    case TypeIds.T_char:
        return new Character(constant.charValue());
    case TypeIds.T_double:
        return new Double(constant.doubleValue());
    case TypeIds.T_float:
        return new Float(constant.floatValue());
    case TypeIds.T_int:
        return new Integer(constant.intValue());
    case TypeIds.T_long:
        return new Long(constant.longValue());
    case TypeIds.T_short:
        return new Short(constant.shortValue());
    case TypeIds.T_JavaLangString:
        return constant.stringValue();
    default:
        return null;
    }
}

From source file:com.codenvy.ide.ext.java.server.internal.core.util.Util.java

License:Open Source License

public static Object getAnnotationMemberValue(MemberValuePair memberValuePair, Constant constant) {
    if (constant == null) {
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }//from w ww  . j  a  va  2 s.  c o m
    switch (constant.typeID()) {
    case TypeIds.T_int:
        memberValuePair.valueKind = IMemberValuePair.K_INT;
        return new Integer(constant.intValue());
    case TypeIds.T_byte:
        memberValuePair.valueKind = IMemberValuePair.K_BYTE;
        return new Byte(constant.byteValue());
    case TypeIds.T_short:
        memberValuePair.valueKind = IMemberValuePair.K_SHORT;
        return new Short(constant.shortValue());
    case TypeIds.T_char:
        memberValuePair.valueKind = IMemberValuePair.K_CHAR;
        return new Character(constant.charValue());
    case TypeIds.T_float:
        memberValuePair.valueKind = IMemberValuePair.K_FLOAT;
        return new Float(constant.floatValue());
    case TypeIds.T_double:
        memberValuePair.valueKind = IMemberValuePair.K_DOUBLE;
        return new Double(constant.doubleValue());
    case TypeIds.T_boolean:
        memberValuePair.valueKind = IMemberValuePair.K_BOOLEAN;
        return Boolean.valueOf(constant.booleanValue());
    case TypeIds.T_long:
        memberValuePair.valueKind = IMemberValuePair.K_LONG;
        return new Long(constant.longValue());
    case TypeIds.T_JavaLangString:
        memberValuePair.valueKind = IMemberValuePair.K_STRING;
        return constant.stringValue();
    default:
        memberValuePair.valueKind = IMemberValuePair.K_UNKNOWN;
        return null;
    }
}

From source file:com.google.gwt.dev.jjs.impl.GwtAstBuilder.java

License:Apache License

private static boolean isCompileTimeConstant(FieldBinding binding) {
    assert !binding.isFinal() || !binding.isVolatile();
    boolean isCompileTimeConstant = binding.isStatic() && binding.isFinal()
            && binding.constant() != Constant.NotAConstant;
    assert !isCompileTimeConstant || binding.type.isBaseType() || (binding.type.id == TypeIds.T_JavaLangString);
    return isCompileTimeConstant;
}

From source file:com.google.gwt.dev.jjs.impl.TypeMap.java

License:Apache License

private JNode internalGet(Binding binding, boolean failOnNull) {
    JNode cached = crossRefMap.get(binding);
    if (cached != null) {
        return cached;
    } else if (binding instanceof BaseTypeBinding) {
        BaseTypeBinding baseTypeBinding = (BaseTypeBinding) binding;
        // see org.eclipse.jdt.internal.compiler.lookup.TypeIds constants
        switch (baseTypeBinding.id) {
        case TypeIds.T_JavaLangObject:
            // here for consistency, should already be cached
            return program.getTypeJavaLangObject();
        case TypeIds.T_char:
            return program.getTypePrimitiveChar();
        case TypeIds.T_byte:
            return program.getTypePrimitiveByte();
        case TypeIds.T_short:
            return program.getTypePrimitiveShort();
        case TypeIds.T_boolean:
            return program.getTypePrimitiveBoolean();
        case TypeIds.T_void:
            return program.getTypeVoid();
        case TypeIds.T_long:
            return program.getTypePrimitiveLong();
        case TypeIds.T_double:
            return program.getTypePrimitiveDouble();
        case TypeIds.T_float:
            return program.getTypePrimitiveFloat();
        case TypeIds.T_int:
            return program.getTypePrimitiveInt();
        case TypeIds.T_JavaLangString:
            // here for consistency, should already be cached
            return program.getTypeJavaLangString();
        case TypeIds.T_null:
            return program.getTypeNull();
        case TypeIds.T_undefined:
        default://  www  .jav a2s  . c  om
            return null;
        }
    } else if (binding instanceof ArrayBinding) {
        ArrayBinding arrayBinding = (ArrayBinding) binding;
        JType elementType = (JType) get(arrayBinding.elementsType(), failOnNull);
        if (elementType == null) {
            return null;
        }
        return program.getTypeArray(elementType);
    } else if (binding instanceof BinaryTypeBinding) {
        BinaryTypeBinding binaryBinding = (BinaryTypeBinding) binding;
        String name = BuildTypeMap.dotify(binaryBinding.compoundName);

        // There may be many BinaryTypeBindings for a single binary type
        JDeclaredType type = externalTypesByName.get(name);
        if (type != null) {
            put(binding, type);
        }
        return type;
    } else if (binding instanceof MethodBinding) {
        MethodBinding b = (MethodBinding) binding;
        JMethod cachedMethod = (JMethod) crossRefMap.get(b);
        if (cachedMethod == null) {
            JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
            if (type == null) {
                return type;
            }
            cachedMethod = getMethodForBinding(type, b);
            if (cachedMethod != null) {
                put(b, cachedMethod);
            }
        } else {
            // Happens sometimes when looking up the type to resolve the binding
            // causes us to also resolve the binding.
        }

        return cachedMethod;
    } else if (binding instanceof FieldBinding) {
        FieldBinding b = (FieldBinding) binding;
        JField cachedField = (JField) crossRefMap.get(b);

        if (cachedField == null) {
            JDeclaredType type = (JDeclaredType) get(b.declaringClass, failOnNull);
            if (type == null) {
                return null;
            }
            cachedField = getFieldForBinding(type, b);
            if (cachedField != null) {
                put(b, cachedField);
            }
        } else {
            // Happens sometimes when looking up the type to resolve the binding
            // causes us to also resolve the binding.
        }

        return cachedField;
    }

    return null;
}

From source file:io.takari.maven.plugins.compile.jdt.ClassfileDigester.java

License:Open Source License

private void updateConstant(Constant constant) {
    updateInt(constant.typeID());//from w  w  w .j a  v a  2s . co  m
    updateString(constant.getClass().getName());
    switch (constant.typeID()) {
    case TypeIds.T_int:
        updateInt(constant.intValue());
        break;
    case TypeIds.T_byte:
        updateByte(constant.byteValue());
        break;
    case TypeIds.T_short:
        updateShort(constant.shortValue());
        break;
    case TypeIds.T_char:
        updateChar(constant.charValue());
        break;
    case TypeIds.T_long:
        updateLong(constant.longValue());
        break;
    case TypeIds.T_float:
        updateFloat(constant.floatValue());
        break;
    case TypeIds.T_double:
        updateDouble(constant.doubleValue());
        break;
    case TypeIds.T_boolean:
        updateBoolean(constant.booleanValue());
        break;
    case TypeIds.T_JavaLangString:
        updateString(constant.stringValue());
        break;
    default:
        throw new IllegalArgumentException("Unexpected constant typeID=" + constant.typeID());
    }
}

From source file:lombok.eclipse.Eclipse.java

License:Open Source License

/**
 * Returns the actual value of the given Literal or Literal-like node.
 *///from   ww w  . j a  v a 2  s. co  m
public static Object calculateValue(Expression e) {
    if (e instanceof Literal) {
        ((Literal) e).computeConstant();
        switch (e.constant.typeID()) {
        case TypeIds.T_int:
            return e.constant.intValue();
        case TypeIds.T_byte:
            return e.constant.byteValue();
        case TypeIds.T_short:
            return e.constant.shortValue();
        case TypeIds.T_char:
            return e.constant.charValue();
        case TypeIds.T_float:
            return e.constant.floatValue();
        case TypeIds.T_double:
            return e.constant.doubleValue();
        case TypeIds.T_boolean:
            return e.constant.booleanValue();
        case TypeIds.T_long:
            return e.constant.longValue();
        case TypeIds.T_JavaLangString:
            return e.constant.stringValue();
        default:
            return null;
        }
    } else if (e instanceof ClassLiteralAccess) {
        return Eclipse.toQualifiedName(((ClassLiteralAccess) e).type.getTypeName());
    } else if (e instanceof SingleNameReference) {
        return new String(((SingleNameReference) e).token);
    } else if (e instanceof QualifiedNameReference) {
        String qName = Eclipse.toQualifiedName(((QualifiedNameReference) e).tokens);
        int idx = qName.lastIndexOf('.');
        return idx == -1 ? qName : qName.substring(idx + 1);
    }

    return null;
}

From source file:org.codehaus.jdt.groovy.internal.compiler.ast.JDTClassNodeBuilder.java

License:Open Source License

private ClassNode configureClass(BinaryTypeBinding type) {
    if (type.id == TypeIds.T_JavaLangObject) {
        return ClassHelper.OBJECT_TYPE;
        // next two clauses - see GRECLIPSE-1521
    } else if (type.id == TypeIds.T_JavaLangString) {
        return ClassHelper.STRING_TYPE;
    } else if (type.id == TypeIds.T_JavaLangClass) {
        return ClassHelper.CLASS_Type;
    }//from   w  w w  . j a  v a2 s.  co  m
    JDTClassNode jcn = new JDTClassNode(type, resolver);
    return jcn;
}

From source file:org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding.java

License:Open Source License

public void computeId() {
    // try to avoid multiple checks against a package/type name
    switch (this.compoundName.length) {

    case 3:/*  w ww  .ja v  a  2s  .co m*/
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;

        char[] packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe
        char[] typeName = this.compoundName[2];
        if (typeName.length == 0)
            return; // just to be safe
        // remaining types MUST be in java.*.*
        if (!CharOperation.equals(TypeConstants.LANG, this.compoundName[1])) {
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.IO)) {
                    switch (typeName[0]) {
                    case 'E':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_EXTERNALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoExternalizable;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_IOEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoException;
                        return;
                    case 'O':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_OBJECTSTREAMEXCEPTION[2]))
                            this.id = TypeIds.T_JavaIoObjectStreamException;
                        return;
                    case 'P':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_PRINTSTREAM[2]))
                            this.id = TypeIds.T_JavaIoPrintStream;
                        return;
                    case 'S':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_IO_SERIALIZABLE[2]))
                            this.id = TypeIds.T_JavaIoSerializable;
                        return;
                    }
                }
                return;
            case 'u':
                if (CharOperation.equals(packageName, TypeConstants.UTIL)) {
                    switch (typeName[0]) {
                    case 'C':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_COLLECTION[2]))
                            this.id = TypeIds.T_JavaUtilCollection;
                        return;
                    case 'I':
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_UTIL_ITERATOR[2]))
                            this.id = TypeIds.T_JavaUtilIterator;
                        return;
                    }
                }
                return;
            }
            return;
        }

        // remaining types MUST be in java.lang.*
        switch (typeName[0]) {
        case 'A':
            switch (typeName.length) {
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_AUTOCLOSEABLE[2]))
                    this.id = TypeIds.T_JavaLangAutoCloseable;
                return;
            case 14:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ASSERTIONERROR[2]))
                    this.id = TypeIds.T_JavaLangAssertionError;
                return;
            }
            return;
        case 'B':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BYTE[2]))
                    this.id = TypeIds.T_JavaLangByte;
                return;
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_BOOLEAN[2]))
                    this.id = TypeIds.T_JavaLangBoolean;
                return;
            }
            return;
        case 'C':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASS[2]))
                    this.id = TypeIds.T_JavaLangClass;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CHARACTER[2]))
                    this.id = TypeIds.T_JavaLangCharacter;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLONEABLE[2]))
                    this.id = TypeIds.T_JavaLangCloneable;
                return;
            case 22:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_CLASSNOTFOUNDEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangClassNotFoundException;
                return;
            }
            return;
        case 'D':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DOUBLE[2]))
                    this.id = TypeIds.T_JavaLangDouble;
                return;
            case 10:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_DEPRECATED[2]))
                    this.id = TypeIds.T_JavaLangDeprecated;
                return;
            }
            return;
        case 'E':
            switch (typeName.length) {
            case 4:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ENUM[2]))
                    this.id = TypeIds.T_JavaLangEnum;
                return;
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ERROR[2]))
                    this.id = TypeIds.T_JavaLangError;
                return;
            case 9:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_EXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangException;
                return;
            }
            return;
        case 'F':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_FLOAT[2]))
                this.id = TypeIds.T_JavaLangFloat;
            return;
        case 'I':
            switch (typeName.length) {
            case 7:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_INTEGER[2]))
                    this.id = TypeIds.T_JavaLangInteger;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ITERABLE[2]))
                    this.id = TypeIds.T_JavaLangIterable;
                return;
            case 24:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ILLEGALARGUMENTEXCEPTION[2]))
                    this.id = TypeIds.T_JavaLangIllegalArgumentException;
                return;
            }
            return;
        case 'L':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_LONG[2]))
                this.id = TypeIds.T_JavaLangLong;
            return;
        case 'N':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_NOCLASSDEFERROR[2]))
                this.id = TypeIds.T_JavaLangNoClassDefError;
            return;
        case 'O':
            switch (typeName.length) {
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OBJECT[2]))
                    this.id = TypeIds.T_JavaLangObject;
                return;
            case 8:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_OVERRIDE[2]))
                    this.id = TypeIds.T_JavaLangOverride;
                return;
            }
            return;
        case 'R':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_RUNTIMEEXCEPTION[2]))
                this.id = TypeIds.T_JavaLangRuntimeException;
            break;
        case 'S':
            switch (typeName.length) {
            case 5:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SHORT[2]))
                    this.id = TypeIds.T_JavaLangShort;
                return;
            case 6:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRING[2]))
                    this.id = TypeIds.T_JavaLangString;
                else if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SYSTEM[2]))
                    this.id = TypeIds.T_JavaLangSystem;
                return;
            case 11:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SAFEVARARGS[2]))
                    this.id = TypeIds.T_JavaLangSafeVarargs;
                return;
            case 12:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUFFER[2]))
                    this.id = TypeIds.T_JavaLangStringBuffer;
                return;
            case 13:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_STRINGBUILDER[2]))
                    this.id = TypeIds.T_JavaLangStringBuilder;
                return;
            case 16:
                if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_SUPPRESSWARNINGS[2]))
                    this.id = TypeIds.T_JavaLangSuppressWarnings;
                return;
            }
            return;
        case 'T':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_THROWABLE[2]))
                this.id = TypeIds.T_JavaLangThrowable;
            return;
        case 'V':
            if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_VOID[2]))
                this.id = TypeIds.T_JavaLangVoid;
            return;
        }
        break;

    case 4:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        packageName = this.compoundName[2];
        if (packageName.length == 0)
            return; // just to be safe
        typeName = this.compoundName[3];
        if (typeName.length == 0)
            return; // just to be safe
        switch (packageName[0]) {
        case 'a':
            if (CharOperation.equals(packageName, TypeConstants.ANNOTATION)) {
                switch (typeName[0]) {
                case 'A':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION[3]))
                        this.id = TypeIds.T_JavaLangAnnotationAnnotation;
                    return;
                case 'D':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationDocumented;
                    return;
                case 'E':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_ELEMENTTYPE[3]))
                        this.id = TypeIds.T_JavaLangAnnotationElementType;
                    return;
                case 'I':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_INHERITED[3]))
                        this.id = TypeIds.T_JavaLangAnnotationInherited;
                    return;
                case 'R':
                    switch (typeName.length) {
                    case 9:
                        if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_RETENTION[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetention;
                        return;
                    case 15:
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_ANNOTATION_RETENTIONPOLICY[3]))
                            this.id = TypeIds.T_JavaLangAnnotationRetentionPolicy;
                        return;
                    }
                    return;
                case 'T':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_ANNOTATION_TARGET[3]))
                        this.id = TypeIds.T_JavaLangAnnotationTarget;
                    return;
                }
            }
            return;
        case 'i':
            if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                if (typeName.length == 0)
                    return; // just to be safe
                switch (typeName[0]) {
                case 'M':
                    if (CharOperation.equals(typeName,
                            TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_$_POLYMORPHICSIGNATURE[3]))
                        this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                    return;
                }
            }
            return;
        case 'r':
            if (CharOperation.equals(packageName, TypeConstants.REFLECT)) {
                switch (typeName[0]) {
                case 'C':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_CONSTRUCTOR[2]))
                        this.id = TypeIds.T_JavaLangReflectConstructor;
                    return;
                case 'F':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_FIELD[2]))
                        this.id = TypeIds.T_JavaLangReflectField;
                    return;
                case 'M':
                    if (CharOperation.equals(typeName, TypeConstants.JAVA_LANG_REFLECT_METHOD[2]))
                        this.id = TypeIds.T_JavaLangReflectMethod;
                    return;
                }
            }
            return;
        }
        break;
    case 5:
        if (!CharOperation.equals(TypeConstants.JAVA, this.compoundName[0]))
            return;
        packageName = this.compoundName[1];
        if (packageName.length == 0)
            return; // just to be safe

        if (CharOperation.equals(TypeConstants.LANG, packageName)) {
            packageName = this.compoundName[2];
            if (packageName.length == 0)
                return; // just to be safe
            switch (packageName[0]) {
            case 'i':
                if (CharOperation.equals(packageName, TypeConstants.INVOKE)) {
                    typeName = this.compoundName[3];
                    if (typeName.length == 0)
                        return; // just to be safe
                    switch (typeName[0]) {
                    case 'M':
                        char[] memberTypeName = this.compoundName[4];
                        if (memberTypeName.length == 0)
                            return; // just to be safe
                        if (CharOperation.equals(typeName,
                                TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[3])
                                && CharOperation.equals(memberTypeName,
                                        TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_POLYMORPHICSIGNATURE[4]))
                            this.id = TypeIds.T_JavaLangInvokeMethodHandlePolymorphicSignature;
                        return;
                    }
                }
                return;
            }
            return;
        }
    }
}

From source file:org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.RoleMigrationImplementor.java

License:Open Source License

private static void doAddMigrateMethod(TypeDeclaration roleClassDecl, char[] selector,
        TypeReference argumentTypeRef, TypeReference returnTypeRef, final String kind, final char[] cacheName) {
    AstGenerator gen = new AstGenerator(roleClassDecl.sourceStart, roleClassDecl.sourceEnd);
    MethodDeclaration migrate = new MethodDeclaration(roleClassDecl.compilationResult) {
        @Override/*from www . j  a  v  a  2s  .c  om*/
        protected void endOfMethodHook(ClassFile classfile) {
            // common code for both variants:
            CodeStream codeStream = classfile.codeStream;
            // if (otherTeam == null)
            BranchLabel goOn = new BranchLabel(codeStream);
            codeStream.aload_1(); //otherTeam / otherBase
            codeStream.ifnonnull(goOn);
            // { throw new NullPointerException("Team/base argument must not be null"); }
            ReferenceBinding npeBinding = (ReferenceBinding) this.scope.getType(JAVA_LANG_NULLPOINTEREXCEPTION,
                    3);
            codeStream.new_(npeBinding);
            codeStream.dup();
            MethodBinding npeStringCtor = getStringArgCtor(npeBinding);
            if (npeStringCtor == null)
                throw new InternalCompilerError(
                        "Expected constructor NullPointerException.<init>(String) not found"); //$NON-NLS-1$
            codeStream.ldc(kind + " argument must not be null"); //$NON-NLS-1$
            codeStream.invoke(Opcodes.OPC_invokespecial, npeStringCtor, npeBinding);
            codeStream.athrow();
            goOn.place();

            // specific code:
            if (kind == TEAM)
                genMigrateToTeamInstructions(codeStream, this.scope.enclosingSourceType());
            else
                genMigrateToBaseInstructions(codeStream, this.scope.enclosingSourceType(), this.scope,
                        cacheName);
        }

        private MethodBinding getStringArgCtor(ReferenceBinding npeBinding) {
            MethodBinding[] ctors = npeBinding.getMethods(TypeConstants.INIT);
            for (MethodBinding ctor : ctors) {
                if (ctor.parameters.length == 1 && ctor.parameters[0].id == TypeIds.T_JavaLangString)
                    return ctor;
            }
            return null;
        }

        @Override
        public void analyseCode(ClassScope classScope, FlowContext flowContext, FlowInfo flowInfo) {
            // noop
        }
    };
    gen.setMethodPositions(migrate);
    migrate.isGenerated = true;

    migrate.modifiers = AccPublic | AccSynchronized;
    migrate.typeParameters = new TypeParameter[] {
            gen.unboundedTypeParameter(RoleMigrationImplementor.TYPEPARAM) };
    migrate.returnType = returnTypeRef;
    migrate.selector = selector;
    migrate.arguments = new Argument[] { gen.argument(("other" + kind).toCharArray(), argumentTypeRef) }; //$NON-NLS-1$
    migrate.statements = new Statement[0];
    migrate.hasParsedStatements = true;
    AstEdit.addMethod(roleClassDecl, migrate);
}