示例#1
0
 public ClassOrInterface getExtendedTypeDeclaration() {
   ProducedType et = getExtendedType();
   if (et == null || !(et.getDeclaration() instanceof ClassOrInterface)) {
     return null;
   } else {
     return (ClassOrInterface) et.getDeclaration();
   }
 }
示例#2
0
 ProducedType substitute(ProducedType pt, Map<TypeParameter, ProducedType> substitutions) {
   Declaration dec;
   if (pt.getDeclaration() instanceof UnionType) {
     UnionType ut = new UnionType(pt.getDeclaration().getUnit());
     List<ProducedType> types = new ArrayList<ProducedType>();
     for (ProducedType ct : pt.getDeclaration().getCaseTypes()) {
       addTypeToUnion(ct, substitutions, types);
     }
     ut.setCaseTypes(types);
     dec = ut;
   } else if (pt.getDeclaration() instanceof IntersectionType) {
     IntersectionType it = new IntersectionType(pt.getDeclaration().getUnit());
     List<ProducedType> types = new ArrayList<ProducedType>();
     for (ProducedType ct : pt.getDeclaration().getSatisfiedTypes()) {
       addTypeToIntersection(ct, substitutions, types);
     }
     it.setSatisfiedTypes(types);
     dec = it.canonicalize();
   } else {
     if (pt.getDeclaration() instanceof TypeParameter) {
       ProducedType sub = substitutions.get(pt.getDeclaration());
       if (sub != null) {
         return sub;
       }
     }
     dec = pt.getDeclaration();
   }
   return substitutedType(dec, pt, substitutions);
 }
  protected void init() {
    com.redhat.ceylon.compiler.typechecker.model.ClassOrInterface decl =
        (com.redhat.ceylon.compiler.typechecker.model.ClassOrInterface)
            producedType.getDeclaration();
    this.declaration = (FreeClassOrInterface) Metamodel.getOrCreateMetamodel(decl);
    java.util.Map<
            ceylon.language.meta.declaration.TypeParameter,
            ceylon.language.meta.declaration.OpenType>
        typeArguments =
            new LinkedHashMap<
                ceylon.language.meta.declaration.TypeParameter,
                ceylon.language.meta.declaration.OpenType>();
    Iterator<? extends ceylon.language.meta.declaration.TypeParameter> typeParameters =
        declaration.getTypeParameterDeclarations().iterator();
    Object it;
    java.util.Map<
            com.redhat.ceylon.compiler.typechecker.model.TypeParameter,
            com.redhat.ceylon.compiler.typechecker.model.ProducedType>
        ptArguments = producedType.getTypeArguments();
    while ((it = typeParameters.next()) != finished_.$get()) {
      com.redhat.ceylon.compiler.java.runtime.metamodel.FreeTypeParameter tp =
          (com.redhat.ceylon.compiler.java.runtime.metamodel.FreeTypeParameter) it;
      com.redhat.ceylon.compiler.typechecker.model.TypeParameter tpDecl =
          (com.redhat.ceylon.compiler.typechecker.model.TypeParameter) tp.declaration;
      com.redhat.ceylon.compiler.typechecker.model.ProducedType ptArg = ptArguments.get(tpDecl);
      OpenType ptArgWrapped = Metamodel.getMetamodel(ptArg);
      typeArguments.put(tp, ptArgWrapped);
    }
    this.typeArguments =
        new InternalMap<
            ceylon.language.meta.declaration.TypeParameter,
            ceylon.language.meta.declaration.OpenType>(
            ceylon.language.meta.declaration.TypeParameter.$TypeDescriptor,
            ceylon.language.meta.declaration.OpenType.$TypeDescriptor,
            typeArguments);

    com.redhat.ceylon.compiler.typechecker.model.ProducedType superType = decl.getExtendedType();
    if (superType != null) {
      com.redhat.ceylon.compiler.typechecker.model.ProducedType superTypeResolved =
          superType.substitute(producedType.getTypeArguments());
      this.superclass =
          (ceylon.language.meta.declaration.OpenClassType)
              Metamodel.getMetamodel(superTypeResolved);
    }

    List<com.redhat.ceylon.compiler.typechecker.model.ProducedType> satisfiedTypes =
        decl.getSatisfiedTypes();
    ceylon.language.meta.declaration.OpenInterfaceType[] interfaces =
        new ceylon.language.meta.declaration.OpenInterfaceType[satisfiedTypes.size()];
    int i = 0;
    for (com.redhat.ceylon.compiler.typechecker.model.ProducedType pt : satisfiedTypes) {
      com.redhat.ceylon.compiler.typechecker.model.ProducedType resolvedPt =
          pt.substitute(producedType.getTypeArguments());
      interfaces[i++] =
          (ceylon.language.meta.declaration.OpenInterfaceType) Metamodel.getMetamodel(resolvedPt);
    }
    this.interfaces =
        Util.sequentialInstance(
            ceylon.language.meta.declaration.OpenInterfaceType.$TypeDescriptor, interfaces);
  }
 private CollectionLiteralAnnotationTerm startCollection(Tree.Term t) {
   Unit unit = t.getUnit();
   // Continue the visit to collect the elements
   ProducedType iteratedType = unit.getIteratedType(parameter().getType());
   TypeDeclaration declaration = iteratedType.getDeclaration();
   LiteralAnnotationTerm factory;
   if (unit.getStringDeclaration().equals(declaration)) {
     factory = StringLiteralAnnotationTerm.FACTORY;
   } else if (unit.getIntegerDeclaration().equals(declaration)) {
     factory = IntegerLiteralAnnotationTerm.FACTORY;
   } else if (unit.getCharacterDeclaration().equals(declaration)) {
     factory = CharacterLiteralAnnotationTerm.FACTORY;
   } else if (unit.getBooleanDeclaration().equals(declaration)) {
     factory = BooleanLiteralAnnotationTerm.FACTORY;
   } else if (unit.getFloatDeclaration().equals(declaration)) {
     factory = FloatLiteralAnnotationTerm.FACTORY;
   } else if (Decl.isEnumeratedTypeWithAnonCases(iteratedType)) {
     factory = ObjectLiteralAnnotationTerm.FACTORY;
   } else if (Decl.isAnnotationClass(declaration)) {
     t.addError(
         "compiler bug: iterables of annotation classes or annotation constructors not supported as literal "
             + (checkingDefaults ? "defaulted parameters" : "arguments"));
     return null;
   } else if (iteratedType.isSubtypeOf(
       ((TypeDeclaration) unit.getLanguageModuleDeclarationDeclaration("Declaration"))
           .getType())) {
     factory = DeclarationLiteralAnnotationTerm.FACTORY;
   } else {
     throw new RuntimeException();
   }
   CollectionLiteralAnnotationTerm result = this.elements;
   this.elements = new CollectionLiteralAnnotationTerm(factory);
   return result;
 }
 private void addLocalType(
     Declaration dec,
     ProducedType type,
     List<TypeDeclaration> localTypes,
     List<ProducedType> visited) {
   if (visited.contains(type)) {
     return;
   } else {
     visited.add(type);
   }
   TypeDeclaration td = type.getDeclaration();
   if (td.getContainer() == dec) {
     boolean found = false;
     for (TypeDeclaration typeDeclaration : localTypes) {
       if (typeDeclaration == td) {
         found = true;
         break;
       }
     }
     if (!found) {
       localTypes.add(td);
     }
   }
   for (ProducedType pt : td.getSatisfiedTypes()) {
     addLocalType(dec, pt, localTypes, visited);
   }
   for (ProducedType pt : type.getTypeArgumentList()) {
     addLocalType(dec, pt, localTypes, visited);
   }
 }
示例#6
0
  @Test
  public void testQualified() {
    ProducedType type = new TypeParser(MockLoader.instance, mockUnit).decodeType("a.b", null);
    Assert.assertNotNull(type);
    TypeDeclaration declaration = type.getDeclaration();
    Assert.assertNotNull(declaration);
    Assert.assertTrue(declaration instanceof Class);
    Assert.assertEquals("a.b", declaration.getName());

    ProducedType qualifyingType = type.getQualifyingType();
    Assert.assertNotNull(qualifyingType);
    TypeDeclaration qualifyingDeclaration = qualifyingType.getDeclaration();
    Assert.assertNotNull(qualifyingDeclaration);
    Assert.assertTrue(qualifyingDeclaration instanceof Class);
    Assert.assertEquals("a", qualifyingDeclaration.getName());
  }
示例#7
0
 public List<TypeDeclaration> getSatisfiedTypeDeclarations() {
   List<ProducedType> sts = getSatisfiedTypes();
   List<TypeDeclaration> list = new ArrayList<TypeDeclaration>(sts.size());
   for (ProducedType pt : sts) {
     list.add(pt == null ? null : pt.getDeclaration());
   }
   return list;
 }
示例#8
0
 public List<TypeDeclaration> getCaseTypeDeclarations() {
   List<ProducedType> caseTypes = getCaseTypes();
   if (caseTypes == null) {
     return null;
   } else {
     List<TypeDeclaration> list = new ArrayList<TypeDeclaration>(caseTypes.size());
     for (ProducedType pt : caseTypes) {
       list.add(pt == null ? null : pt.getDeclaration());
     }
     return list;
   }
 }
示例#9
0
  @Test
  public void testQualifiedAndParameterised() {
    ProducedType type =
        new TypeParser(MockLoader.instance, mockUnit).decodeType("t2<a,b>.t2<c,d>", null);
    Assert.assertNotNull(type);
    TypeDeclaration declaration = type.getDeclaration();
    Assert.assertNotNull(declaration);
    Assert.assertTrue(declaration instanceof Class);
    Assert.assertEquals("t2.t2", declaration.getName());
    Assert.assertEquals(2, type.getTypeArgumentList().size());

    // c
    ProducedType c = type.getTypeArgumentList().get(0);
    Assert.assertEquals("c", c.getDeclaration().getName());
    Assert.assertTrue(c.getDeclaration() instanceof Class);

    // d
    ProducedType d = type.getTypeArgumentList().get(1);
    Assert.assertEquals("d", d.getDeclaration().getName());
    Assert.assertTrue(d.getDeclaration() instanceof Class);

    ProducedType qualifyingType = type.getQualifyingType();
    Assert.assertNotNull(qualifyingType);
    TypeDeclaration qualifyingDeclaration = qualifyingType.getDeclaration();
    Assert.assertNotNull(qualifyingDeclaration);
    Assert.assertTrue(qualifyingDeclaration instanceof Class);
    Assert.assertEquals("t2", qualifyingDeclaration.getName());
    Assert.assertEquals(2, qualifyingType.getTypeArgumentList().size());

    // a
    ProducedType a = qualifyingType.getTypeArgumentList().get(0);
    Assert.assertEquals("a", a.getDeclaration().getName());
    Assert.assertTrue(a.getDeclaration() instanceof Class);

    // b
    ProducedType b = qualifyingType.getTypeArgumentList().get(1);
    Assert.assertEquals("b", b.getDeclaration().getName());
    Assert.assertTrue(b.getDeclaration() instanceof Class);
  }
示例#10
0
 @Test
 public void testParams() {
   ProducedType type = new TypeParser(MockLoader.instance, mockUnit).decodeType("t2<b,c>", null);
   Assert.assertNotNull(type);
   TypeDeclaration declaration = type.getDeclaration();
   Assert.assertNotNull(declaration);
   Assert.assertTrue(declaration instanceof Class);
   Assert.assertEquals("t2", declaration.getName());
   Assert.assertEquals(2, type.getTypeArgumentList().size());
   Assert.assertEquals("b", type.getTypeArgumentList().get(0).getDeclaration().getName());
   Assert.assertTrue(type.getTypeArgumentList().get(0).getDeclaration() instanceof Class);
   Assert.assertEquals("c", type.getTypeArgumentList().get(1).getDeclaration().getName());
   Assert.assertTrue(type.getTypeArgumentList().get(1).getDeclaration() instanceof Class);
 }
示例#11
0
 @Test
 public void testIntersection() {
   ProducedType type = new TypeParser(MockLoader.instance, mockUnit).decodeType("a&b&c", null);
   Assert.assertNotNull(type);
   TypeDeclaration declaration = type.getDeclaration();
   Assert.assertNotNull(declaration);
   Assert.assertTrue(declaration instanceof IntersectionType);
   IntersectionType intersection = (IntersectionType) declaration;
   List<ProducedType> types = intersection.getSatisfiedTypes();
   Assert.assertEquals(3, types.size());
   Assert.assertEquals("a", types.get(0).getDeclaration().getName());
   Assert.assertTrue(types.get(0).getDeclaration() instanceof Class);
   Assert.assertEquals("b", types.get(1).getDeclaration().getName());
   Assert.assertTrue(types.get(1).getDeclaration() instanceof Class);
   Assert.assertEquals("c", types.get(2).getDeclaration().getName());
   Assert.assertTrue(types.get(2).getDeclaration() instanceof Class);
 }
  private boolean isConstantValue(Declaration d) {
    if (d instanceof Value) {
      Value value = (Value) d;
      if (value.isShared() && !value.isVariable()) {
        Unit unit = value.getUnit();
        TypeDeclaration type = value.getTypeDeclaration();

        if (type == unit.getSequentialDeclaration()) {
          ProducedType elementType = unit.getIteratedType(value.getType());
          type = elementType.getDeclaration();
        }

        if (unit.getStringDeclaration().equals(type)
            || unit.getIntegerDeclaration().equals(type)
            || unit.getFloatDeclaration().equals(type)
            || unit.getCharacterDeclaration().equals(type)) {
          return true;
        }
      }
    }
    return false;
  }
示例#13
0
 private List<ProducedType> getSupertypes(List<ProducedType> list) {
   if (isWellDefined() && Util.addToSupertypes(list, this)) {
     ProducedType extendedType = getExtendedType();
     if (extendedType != null) {
       extendedType.getSupertypes(list);
     }
     for (ProducedType dst : getSatisfiedTypes()) {
       dst.getSupertypes(list);
     }
     ProducedType selfType = getSelfType();
     if (selfType != null) {
       if (!(selfType.getDeclaration()
           instanceof TypeParameter)) { // TODO: is this really correct???
         selfType.getSupertypes(list);
       }
     }
     List<ProducedType> caseTypes = getCaseTypes();
     if (caseTypes != null /*&& !getDeclaration().getCaseTypes().isEmpty()*/) {
       for (ProducedType t : caseTypes) {
         List<ProducedType> candidates = t.getSupertypes();
         for (ProducedType st : candidates) {
           boolean include = true;
           for (ProducedType ct : getDeclaration().getCaseTypes()) {
             if (!ct.isSubtypeOf(st)) {
               include = false;
               break;
             }
           }
           if (include) {
             Util.addToSupertypes(list, st);
           }
         }
       }
     }
   }
   return list;
 }
示例#14
0
 /** Search for the most-specialized supertype satisfying the given predicate. */
 private ProducedType getSupertype(
     final Criteria c, List<ProducedType> list, final TypeDeclaration ignoringSelfType) {
   if (c.satisfies(getDeclaration())) {
     return qualifiedByDeclaringType();
   }
   if (isWellDefined() && Util.addToSupertypes(list, this)) {
     // search for the most-specific supertype
     // for the given declaration
     ProducedType result = null;
     ProducedType extendedType = getInternalExtendedType();
     if (extendedType != null) {
       ProducedType possibleResult = extendedType.getSupertype(c, list, ignoringSelfType);
       if (possibleResult != null) {
         result = possibleResult;
       }
     }
     for (ProducedType dst : getInternalSatisfiedTypes()) {
       ProducedType possibleResult = dst.getSupertype(c, list, ignoringSelfType);
       if (possibleResult != null
           && (result == null || possibleResult.isSubtypeOf(result, ignoringSelfType))) {
         result = possibleResult;
       }
     }
     if (!getDeclaration().equals(ignoringSelfType)) {
       ProducedType selfType = getInternalSelfType();
       if (selfType != null) {
         ProducedType possibleResult = selfType.getSupertype(c, list, ignoringSelfType);
         if (possibleResult != null
             && (result == null || possibleResult.isSubtypeOf(result, ignoringSelfType))) {
           result = possibleResult;
         }
       }
     }
     final List<ProducedType> caseTypes = getInternalCaseTypes();
     if (caseTypes != null && !caseTypes.isEmpty()) {
       // first find a common superclass or superinterface
       // declaration that satisfies the criteria, ignoring
       // type arguments for now
       Criteria c2 =
           new Criteria() {
             @Override
             public boolean satisfies(TypeDeclaration type) {
               if (c.satisfies(type)) {
                 for (ProducedType ct : caseTypes) {
                   if (ct.getSupertype(type, ignoringSelfType) == null) {
                     return false;
                   }
                 }
                 return true;
               } else {
                 return false;
               }
             }
           };
       ProducedType stc = caseTypes.get(0).getSupertype(c2, list, ignoringSelfType);
       if (stc != null) {
         // we found the declaration, now try to construct a
         // produced type that is a true common supertype
         ProducedType candidateResult =
             getCommonSupertype(caseTypes, stc.getDeclaration(), ignoringSelfType);
         if (candidateResult != null
             && (result == null || candidateResult.isSubtypeOf(result, ignoringSelfType))) {
           result = candidateResult;
         }
       }
     }
     return result;
   } else {
     return null;
   }
 }
示例#15
0
 /** Is this type exactly the same type as the given type? */
 public boolean isExactly(ProducedType type) {
   if (getDeclaration() instanceof BottomType) {
     return type.getDeclaration() instanceof BottomType;
   } else if (getDeclaration() instanceof UnionType) {
     List<ProducedType> cases = getCaseTypes();
     if (type.getDeclaration() instanceof UnionType) {
       List<ProducedType> otherCases = type.getCaseTypes();
       if (cases.size() != otherCases.size()) {
         return false;
       } else {
         for (ProducedType c : cases) {
           boolean found = false;
           for (ProducedType oc : otherCases) {
             if (c.isExactly(oc)) {
               found = true;
               break;
             }
           }
           if (!found) {
             return false;
           }
         }
         return true;
       }
     } else if (cases.size() == 1) {
       ProducedType st = cases.get(0);
       return st.isExactly(type);
     } else {
       return false;
     }
   } else if (getDeclaration() instanceof IntersectionType) {
     List<ProducedType> types = getSatisfiedTypes();
     if (type.getDeclaration() instanceof IntersectionType) {
       List<ProducedType> otherTypes = type.getSatisfiedTypes();
       if (types.size() != otherTypes.size()) {
         return false;
       } else {
         for (ProducedType c : types) {
           boolean found = false;
           for (ProducedType oc : otherTypes) {
             if (c.isExactly(oc)) {
               found = true;
               break;
             }
           }
           if (!found) {
             return false;
           }
         }
         return true;
       }
     } else if (types.size() == 1) {
       ProducedType st = types.get(0);
       return st.isExactly(type);
     } else {
       return false;
     }
   } else if (type.getDeclaration() instanceof UnionType) {
     List<ProducedType> otherCases = type.getCaseTypes();
     if (otherCases.size() == 1) {
       ProducedType st = otherCases.get(0);
       return this.isExactly(st);
     } else {
       return false;
     }
   } else if (type.getDeclaration() instanceof IntersectionType) {
     List<ProducedType> otherTypes = type.getSatisfiedTypes();
     if (otherTypes.size() == 1) {
       ProducedType st = otherTypes.get(0);
       return this.isExactly(st);
     } else {
       return false;
     }
   } else {
     if (!type.getDeclaration().equals(getDeclaration())) {
       return false;
     } else {
       ProducedType qt = getQualifyingType();
       ProducedType tqt = type.getQualifyingType();
       if (qt == null) {
         if (tqt != null) {
           return false;
         }
       } else {
         if (tqt == null) {
           return false;
         } else {
           TypeDeclaration totd = (TypeDeclaration) type.getDeclaration().getContainer();
           ProducedType tqts = tqt.getSupertype(totd);
           TypeDeclaration otd = (TypeDeclaration) getDeclaration().getContainer();
           ProducedType qts = qt.getSupertype(otd);
           if (!qts.isExactly(tqts)) {
             return false;
           }
         }
       }
       for (TypeParameter p : getDeclaration().getTypeParameters()) {
         ProducedType arg = getTypeArguments().get(p);
         ProducedType otherArg = type.getTypeArguments().get(p);
         if (arg == null || otherArg == null) {
           return false;
           /*throw new RuntimeException(
           "Missing type argument for: " +
                   p.getName() + " of " +
                   getDeclaration().getName());*/
         } else if (!arg.isExactly(otherArg)) {
           return false;
         }
       }
       return true;
     }
   }
 }
示例#16
0
 /** Is this type a subtype of the given type? Ignore a certain self type constraint. */
 public boolean isSubtypeOf(ProducedType type, TypeDeclaration selfTypeToIgnore) {
   if (getDeclaration() instanceof BottomType) {
     return true;
   } else if (type.getDeclaration() instanceof BottomType) {
     return false;
   } else if (getDeclaration() instanceof UnionType) {
     for (ProducedType ct : getInternalCaseTypes()) {
       if (ct == null || !ct.isSubtypeOf(type, selfTypeToIgnore)) {
         return false;
       }
     }
     return true;
   } else if (type.getDeclaration() instanceof UnionType) {
     for (ProducedType ct : type.getInternalCaseTypes()) {
       if (ct != null && isSubtypeOf(ct, selfTypeToIgnore)) {
         return true;
       }
     }
     return false;
   } else if (type.getDeclaration() instanceof IntersectionType) {
     for (ProducedType ct : type.getInternalSatisfiedTypes()) {
       if (ct != null && !isSubtypeOf(ct, selfTypeToIgnore)) {
         return false;
       }
     }
     return true;
   } else if (getDeclaration() instanceof IntersectionType) {
     for (ProducedType ct : getInternalSatisfiedTypes()) {
       if (ct == null || ct.isSubtypeOf(type, selfTypeToIgnore)) {
         return true;
       }
     }
     return false;
   } else {
     ProducedType st = getSupertype(type.getDeclaration(), selfTypeToIgnore);
     if (st == null) {
       return false;
     } else {
       ProducedType stqt = st.getQualifyingType();
       ProducedType tqt = type.getQualifyingType();
       if (stqt == null) {
         if (tqt != null) {
           // probably extraneous!
           return false;
         }
       } else {
         if (tqt == null) {
           // probably extraneous!
           return false;
         } else {
           // note that the qualifying type of the
           // given type may be an invariant subtype
           // of the type that declares the member
           // type, as long as it doesn't refine the
           // member type
           TypeDeclaration totd = (TypeDeclaration) type.getDeclaration().getContainer();
           ProducedType tqts = tqt.getSupertype(totd);
           if (!stqt.isSubtypeOf(tqts)) {
             return false;
           }
         }
       }
       for (TypeParameter p : type.getDeclaration().getTypeParameters()) {
         ProducedType arg = st.getTypeArguments().get(p);
         ProducedType otherArg = type.getTypeArguments().get(p);
         if (arg == null || otherArg == null) {
           /*throw new RuntimeException("Missing type argument for type parameter: " +
           p.getName() + " of " +
           type.getDeclaration().getName());*/
           return false;
         } else if (p.isCovariant()) {
           if (!arg.isSubtypeOf(otherArg)) {
             return false;
           }
         } else if (p.isContravariant()) {
           if (!otherArg.isSubtypeOf(arg)) {
             return false;
           }
         } else {
           if (!arg.isExactly(otherArg)) {
             return false;
           }
         }
       }
       return true;
     }
   }
 }
示例#17
0
  /**
   * Get the supertype which defines the most-refined member with the given name.
   *
   * @param signature
   */
  private SupertypeDeclaration getSupertypeDeclaration(
      final String name, final List<ProducedType> signature, final boolean variadic) {
    class ExactCriteria implements ProducedType.Criteria {
      @Override
      public boolean satisfies(TypeDeclaration type) {
        // do not look in ourselves
        if (type == TypeDeclaration.this) return false;
        Declaration d = type.getDirectMember(name, signature, variadic);
        if (d != null && d.isShared() && isResolvable(d)) {
          // only accept abstractions if we don't have a signature
          return !isAbstraction(d) || signature == null;
        } else {
          return false;
        }
      }

      @Override
      public boolean isMemberLookup() {
        return true;
      }
    };
    class LooseCriteria implements ProducedType.Criteria {
      @Override
      public boolean satisfies(TypeDeclaration type) {
        // do not look in ourselves
        if (type == TypeDeclaration.this) return false;
        Declaration d = type.getDirectMember(name, null, false);
        if (d != null && d.isShared() && isResolvable(d)) {
          // only accept abstractions
          return isAbstraction(d);
        } else {
          return false;
        }
      }

      @Override
      public boolean isMemberLookup() {
        return true;
      }
    };
    // this works by finding the most-specialized supertype
    // that defines the member
    ProducedType st = getType().getSupertype(new ExactCriteria());
    if (st == null) {
      // try again, ignoring the given signature
      st = getType().getSupertype(new LooseCriteria());
    }
    if (st == null) {
      // no such member
      return new SupertypeDeclaration(null, false);
    } else if (st.getDeclaration() instanceof UnknownType) {
      // we're dealing with an ambiguous member of an
      // intersection type
      // TODO: this is pretty fragile - it depends upon
      //      the fact that getSupertype() just happens
      //      to return an UnknownType instead of null
      //      in this case
      return new SupertypeDeclaration(null, true);
    } else {
      // we got exactly one uniquely-defined member
      Declaration member = st.getDeclaration().getDirectMember(name, signature, variadic);
      return new SupertypeDeclaration(member, false);
    }
  }
示例#18
0
 public boolean isOptionalType(ProducedType pt) {
   return getNothingDeclaration().getType().isSubtypeOf(pt)
       && !pt.getDeclaration().equals(getVoidDeclaration());
 }
示例#19
0
  @Test
  public void testUnionParams() {
    ProducedType type =
        new TypeParser(MockLoader.instance, mockUnit).decodeType("a|t2<b|c,t2<d,e|f>>", null);
    Assert.assertNotNull(type);
    TypeDeclaration declaration = type.getDeclaration();
    Assert.assertNotNull(declaration);
    Assert.assertTrue(declaration instanceof UnionType);
    UnionType union = (UnionType) declaration;
    List<ProducedType> caseTypes = union.getCaseTypes();
    Assert.assertEquals(2, caseTypes.size());

    // a
    Assert.assertEquals("a", caseTypes.get(0).getDeclaration().getName());
    Assert.assertTrue(caseTypes.get(0).getDeclaration() instanceof Class);

    // first t2
    ProducedType firstT2 = caseTypes.get(1);
    TypeDeclaration firstT2Declaration = firstT2.getDeclaration();
    Assert.assertNotNull(firstT2Declaration);
    Assert.assertTrue(firstT2Declaration instanceof Class);
    Assert.assertEquals("t2", firstT2Declaration.getName());
    Assert.assertEquals(2, firstT2.getTypeArgumentList().size());

    // b|c
    ProducedType bc = firstT2.getTypeArgumentList().get(0);
    Assert.assertTrue(bc.getDeclaration() instanceof UnionType);
    Assert.assertEquals(2, bc.getDeclaration().getCaseTypes().size());

    // b
    ProducedType b = bc.getDeclaration().getCaseTypes().get(0);
    Assert.assertEquals("b", b.getDeclaration().getName());
    Assert.assertTrue(b.getDeclaration() instanceof Class);

    // c
    ProducedType c = bc.getDeclaration().getCaseTypes().get(1);
    Assert.assertEquals("c", c.getDeclaration().getName());
    Assert.assertTrue(c.getDeclaration() instanceof Class);

    // second t2
    ProducedType secondT2 = firstT2.getTypeArgumentList().get(1);
    TypeDeclaration secondT2Declaration = firstT2.getDeclaration();
    Assert.assertNotNull(secondT2Declaration);
    Assert.assertTrue(secondT2Declaration instanceof Class);
    Assert.assertEquals("t2", secondT2Declaration.getName());
    Assert.assertEquals(2, secondT2.getTypeArgumentList().size());

    // d
    ProducedType d = secondT2.getTypeArgumentList().get(0);
    Assert.assertEquals("d", d.getDeclaration().getName());
    Assert.assertTrue(d.getDeclaration() instanceof Class);

    // e|f
    ProducedType ef = secondT2.getTypeArgumentList().get(1);
    Assert.assertTrue(ef.getDeclaration() instanceof UnionType);
    Assert.assertEquals(2, ef.getDeclaration().getCaseTypes().size());

    // e
    ProducedType e = ef.getDeclaration().getCaseTypes().get(0);
    Assert.assertEquals("e", e.getDeclaration().getName());
    Assert.assertTrue(e.getDeclaration() instanceof Class);

    // f
    ProducedType f = ef.getDeclaration().getCaseTypes().get(1);
    Assert.assertEquals("f", f.getDeclaration().getName());
    Assert.assertTrue(f.getDeclaration() instanceof Class);
  }