private List<IRType> getBoundedParameterTypeDescriptors(IConstructorInfo mi) { if (mi.getParameters().length == 0) { return Collections.emptyList(); } if (mi instanceof IJavaConstructorInfo) { return IRTypeResolver.getDescriptors( ((IJavaConstructorInfo) mi).getJavaConstructor().getParameterTypes()); } else if (mi instanceof IGosuConstructorInfo) { IReducedDynamicFunctionSymbol dfs = ((IGosuConstructorInfo) mi).getDfs(); while (dfs instanceof ReducedParameterizedDynamicFunctionSymbol) { ReducedParameterizedDynamicFunctionSymbol pdfs = (ReducedParameterizedDynamicFunctionSymbol) dfs; dfs = pdfs.getBackingDfs(); } List<IRType> boundedTypes = new ArrayList<IRType>(dfs.getArgs().size()); if (IGosuClass.ProxyUtil.isProxy(dfs.getGosuClass())) { return getBoundedParamTypesFromProxiedClass(dfs); } for (int i = 0; i < dfs.getArgs().size(); i++) { boundedTypes.add( IRTypeResolver.getDescriptor( TypeLord.getDefaultParameterizedTypeWithTypeVars(dfs.getArgs().get(i).getType()))); } return boundedTypes; } else { return getTypeDescriptors(mi.getParameters()); } }
public Class defineClass(ICompilableTypeInternal gsClass, boolean useSingleServingLoader) throws ClassNotFoundException { try { if (gsClass instanceof IGosuClassInternal && ((IGosuClassInternal) gsClass).hasBackingClass()) { return ((IGosuClassInternal) gsClass).getBackingClass(); } // there is no point in defining eval classes in a single serving class loader (it wastes // memory) if (useSingleServingLoader || TypeLord.isEvalProgram(gsClass) || isThrowawayProgram(gsClass) || isEnclosingTypeInSingleServingLoader(gsClass) || hasDiscreteNamespace(gsClass.getNamespace())) { // These classes are "fire and forget"; they need to be disposable after they run, // so we load them in a separate class loader so we can unload them -- it's the only // way to unload a class in java. return defineClassInLoader(gsClass, true); } return findOrDefineClass(gsClass); } catch (Exception e) { throw GosuExceptionUtil.forceThrow(e, gsClass.getName()); } }
@Override public IGenericTypeVariable[] getTypeVariables(IJavaMethodInfo javaMethodInfo) { IJavaClassTypeVariable[] rawTypeParams = getTypeParameters(); IType declClass = TypeSystem.get(getEnclosingClass()); TypeVarToTypeMap actualParamByVarName = TypeLord.mapTypeByVarName(declClass, declClass); FunctionType functionType = new FunctionType(javaMethodInfo, true); return GenericTypeVariable.convertTypeVars(functionType, rawTypeParams, actualParamByVarName); }
private IType findCommonClass(IType t1, IType t2) { do { t1 = t1.getSupertype(); if (t1 == null) { return JavaTypes.OBJECT(); } t1 = TypeLord.getPureGenericType(t1); } while (!t1.isAssignableFrom(t2)); return t1; }
public static String getJavaName(IType type) { if (type != null) { type = TypeLord.getPureGenericType(type); IType outerType = type.getEnclosingType(); if (outerType != null) { return getJavaName(outerType) + "$" + type.getRelativeName(); } return type.getName(); } return null; }
private Constructor getJavaConstructorFromProxy(IReducedDynamicFunctionSymbol dfs) { IType proxyType = dfs.getGosuClass(); IJavaType javaType = (IJavaType) IGosuClass.ProxyUtil.getProxiedType(proxyType); IType[] boundedDfsParams = new IType[dfs.getArgs().size()]; for (int i = 0; i < boundedDfsParams.length; i++) { IType param = dfs.getArgs().get(i).getType(); if (param instanceof ITypeVariableType && param.getEnclosingType() instanceof IGosuClass) { param = ((ITypeVariableType) param).getBoundingType(); } boundedDfsParams[i] = param; } javaType = (IJavaType) TypeLord.getDefaultParameterizedType(javaType); IJavaConstructorInfo jmi = (IJavaConstructorInfo) ((IRelativeTypeInfo) javaType.getTypeInfo()).getConstructor(javaType, boundedDfsParams); return jmi.getRawConstructor(); }
@Override public IType getActualType(TypeVarToTypeMap typeMap, boolean bKeepTypeVars) { IType typeFromMap = typeMap.getByMatcher(this, JavaClassTypeVarMatcher.instance()); if (typeFromMap != null && !(typeFromMap instanceof ErrorType)) { if (typeFromMap.getName().equals(getName())) { IType boundingType = ((ITypeVariableType) typeFromMap).getBoundingType(); IType boundingTypeFromMap = TypeLord.getActualType(boundingType, typeMap, bKeepTypeVars); if (boundingType != boundingTypeFromMap) { TypeVariableDefinitionImpl tvd = ((TypeVariableDefinitionImpl) ((ITypeVariableType) typeFromMap).getTypeVarDef()) .clone(boundingTypeFromMap); typeFromMap = new TypeVariableType( tvd, ((ITypeVariableType) typeFromMap).getTypeVarDef().getEnclosingType() instanceof IFunctionType); ((ITypeVariableType) typeFromMap).getTypeVarDef().setVariance(getVariance()); } } return typeFromMap; } else { return TypeSystem.getErrorType(getName()); } }