Examples of xtc.type.Type

xtc.type.Type
The superclass of all types.
The class hierarchy for types distinguishes basic from wrapped types, with wrapped types providing additional information for basic types. For each basic type, this class provides isName() and toName() methods to replace instanceof tests and casts, respectively. For each wrapped type, this class additionally provides a hasName() method, which identifies instances of the wrapped type even if they are wrapped inside another (wrapped) type. In other words, invocations of hasName() are forwarded across wrapped types while invocations of isName() only apply to the outermost type object. For wrapped types, invocations of toName() are also forwarded across (other) wrapped types.
As an example, consider an int type wrapped in an annotated type and an alias type:
```
 Type i = NumberT.INT; Type j = new AnnotatedT(i); Type k = new AliasT("alias", j); 
```
Then the following method invocations have the following results:
```
 k.isAlias()        ⇒ true k.hasAlias()       ⇒ true k.toAlias()        ⇒ k k.isAnnotated()    ⇒ false k.hasAnnotated()   ⇒ true k.toAnnotated()    ⇒ j k.isInteger()      ⇒ false k.toInteger()      ⇒ error 
```
The {@link #resolve()} method can be used to strip any wrappedtypes:
```
 Type r = k.resolve(); r.isAlias()        ⇒ false r.isAnnotated()    ⇒ false r.isInteger()      ⇒ true r.toInteger()      ⇒ i 
```
The {@link Tag} enumeration also identifies particular types.A type's tag can be accessed through {@link #tag()}, which is forwarded across wrapped types, and through {@link #wtag()}, which is not forwarded across wrapped types. As a result, tag() identifies basic types independent of whether they are wrapped or not, while wtag() always identifies the outermost type:
```
 k.tag()            ⇒ Tag.INTEGER k.wtag()           ⇒ Tag.ALIAS i.tag()            ⇒ Tag.INTEGER i.tag()            ⇒ Tag.INTEGER 
```
Each type can have one or more of the following annotations:
- Its source location represented as a {@link Location}.
- Its source language represented as a {@link Language} tag.
- Its scope represented as a {@link String}.
- Its constant value represented as a {@link Constant}.
- Its memory shape represented as a {@link Reference}. Only lvalues can have a shape.
- Its attributes represented as a list of {@link Attribute}values.
For each kind of annotation, this class defines tester, getter, and setter methods. The tester and getter methods come in two versions, one that is forwarded across wrapped types and one that uses a boolean parameter to control forwarding. @author Robert Grimm @version $Revision: 1.112 $

        // pass the value through to existing variant types.
        for (Production p : m.productions) {
          if (AST.isDynamicNode(p.type) &&
              AST.isGenericNode(p.type) &&
              ! analyzer.setsValue(p.choice, false)) {
            final Type t = gtyper.type(p, false);
            if (! t.isError()) setType(p, t);
          }
        }


        // Pull.
        isPushMode = false;

View Full Code Here

    pushPull(m);


    // Process any remaining generic productions.
    for (Production p : m.productions) {
      if (AST.isDynamicNode(p.type) && AST.isGenericNode(p.type)) {
        Type t = gtyper.type(p, true);


        if (! t.isError()) {
          setType(p, t);
          productions.add(p);
        }
      }
    }

View Full Code Here

    dispatch(p.choice);


    // Update the production's type in pull mode by unifying the
    // alternatives' types.
    if (! isPushMode) {
      Type    result   = Wildcard.TYPE;
      boolean seenWild = false; // Flag for having seen a wildcard.
      boolean seenPoly = false; // Flag for having seen a polymorphic variant.


      loop: for (Type t : types) {
        switch (t.tag()) {
        case ERROR:
          result = ErrorT.TYPE;
          break loop;


        case WILDCARD:
          seenWild = true;
          if (seenPoly) {
            runtime.error("production requires polymorphic variant", p);
            runtime.errConsole().loc(p).
              pln(": error: but has alternatives without static type").flush();
            result = ErrorT.TYPE;
            break loop;
          }
          break;


        case VARIANT:
          if (seenPoly) {
            result = merge(result.toVariant(), t.toVariant(), p);
            if (result.isError()) break loop;


          } else if (result.isWildcard()) {
            result = t;


          } else if (! result.equals(t)) {
            if (isGeneric) {
              runtime.error("variant '" + result.toVariant().getName() + "' " +
                            "overlaps with '" + t.toVariant().getName() + "'",p);
              result = ErrorT.TYPE;
              break loop;


            } else if (seenWild) {
              runtime.error("production requires polymorphic variant", p);
              runtime.errConsole().loc(p).
                pln(": error: but has alternatives without static type").flush();
              result = ErrorT.TYPE;
              break loop;


            } else {
              VariantT v = result.toVariant();
              result     = merge(ast.toVariant(p.qName.name, true), v, p);
              if (result.isError()) break loop;
              result     = merge(result.toVariant(), t.toVariant(), p);
              if (result.isError()) break loop;
              seenPoly   = true;
            }
          }
          break;


        default:
          throw new AssertionError("Unrecognized type " + t);
        }
      }


      // If we have a meaningful result, update the production's type.
      if (! result.isWildcard()) {
        setType(p, result);


        final Type r = result.resolve();
        if (r.isVariant() && ! r.toVariant().isPolymorphic()) {
          // Push the production's variant type.
          productions.add(p);
        }
      }
    }

View Full Code Here

      }


      // Update the element type.
      if ((null != element) && ! element.isError()) {
        for (Binding b : bindings) {
          Type t = analyzer.type(b.element);
          if (AST.isList(t)) t = AST.getArgument(t);


          Type u = ast.unify(element, t, true);
          if (u.isError()) {
            runtime.error("unable to determine consistent list element type", s);
            runtime.errConsole().loc(s).p(": error: 1st type is '");
            ast.print(element, runtime.errConsole(), false, true, null);
            runtime.errConsole().pln("'");
            runtime.errConsole().loc(s).p(": error: 2nd type is '");

View Full Code Here

0 1 2

TOP

Related Classes of xtc.type.Type

xtc.parser.Annotator

xtc.parser.CodeGenerator

xtc.parser.DirectLeftRecurser

xtc.parser.ListMaker

xtc.parser.MetaDataSetter

xtc.parser.Resolver

xtc.parser.Transformer$Desugarer

xtc.parser.Transformer$Lifter

xtc.parser.TreeTyper

xtc.parser.VariantSorter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.