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());
    }
  }
Пример #2
0
  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());
    }
  }
Пример #3
0
 @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);
 }
Пример #4
0
 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;
 }
Пример #5
0
 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());
   }
 }