Examples of edu.mit.csail.sdg.alloy4.Pos

edu.mit.csail.sdg.alloy4.ErrorWarning
Immutable; stores the filename and line/column position.
Invariant: filename!=null && x>0 && y>0 && ((y2>y && x2>0) || (y2==y && x2>=x))
Thread Safety: Safe (since objects of this class are immutable).

   /** Converts this into an "integer expression" if possible; otherwise, returns an Expr with a nonempty error list */
   public final Expr typecheck_as_int() {
      if (!errors.isEmpty() || type.is_int) return this;
      if (Type.SIGINT2INT && type.intersects(SIGINT.type)) return cast2int();
      String msg = "This must be an integer expression.\nInstead, it has the following possible type(s):\n"+type;
      return NOOP.make(null, this, new ErrorType(span(), msg), 0);
   }

View Full Code Here

   /** Converts this into a "set or relation" if possible; otherwise, returns an Expr with a nonempty error list */
   public final Expr typecheck_as_set() {
      if (!errors.isEmpty() || type.size()>0) return this;
      if (Type.INT2SIGINT && type.is_int) return cast2sigint();
      String msg = "This must be a set or relation.\nInstead, it has the following possible type(s):\n"+type;
      return NOOP.make(null, this, new ErrorType(span(), msg), 0);
   }

View Full Code Here


   /** Convenience method that generates a type error with "msg" as the message,
    * and includes the left and right bounding types in the message.
    */
   private static ErrorType error(Pos pos, String msg, Expr left, Expr right) {
      return new ErrorType(pos, msg+"\nLeft type = "+left.type+"\nRight type = "+right.type);
   }

View Full Code Here

        } else {
            newBody = newBody.typecheck_as_set();
            if (newBody.ambiguous) newBody = newBody.resolve_as_set(null);
            if (newBody.errors.size()>0) throw newBody.errors.pick();
            if (newBody.type.arity() != returnDecl.type.arity())
               throw new ErrorType(newBody.span(),
               "Function return type is "+returnDecl.type+",\nso the body must be a relation with arity "
               +returnDecl.type.arity()+".\nSo the body's type cannot be: "+newBody.type);
        }
        if (newBody.mult!=0) throw new ErrorSyntax(newBody.span(), "Multiplicity expression not allowed here.");
        this.body = newBody;

View Full Code Here

           "perhaps you used ( ) when you should have used [ ]\n");
        for(Expr x:choices) {
            pos = pos.merge(x.span());
            if (x instanceof ExprBadCall || x instanceof ExprBadJoin) sb.append('\n').append(x.errors.pick().msg);
        }
        return new ErrorType(pos, sb.toString());
    }

View Full Code Here


    //============================================================================================================//


    /** Construct an ExprChoice node. */
    public static Expr make(Pos pos, ConstList<Expr> choices, ConstList<String> reasons) {
        if (choices.size()==0) return new ExprBad(pos, "", new ErrorType(pos, "This expression failed to be typechecked."));
        if (choices.size()==1 && choices.get(0).errors.isEmpty()) return choices.get(0); // Shortcut
        Type type=EMPTY;
        boolean first=true;
        long weight=0;
        for(Expr x:choices) {

View Full Code Here


   /** Convenience method that generates a type warning with "msg" as the message,
    * and includes the left and right bounding types in the message.
    */
   private ErrorWarning warn(String msg) {
      return new ErrorWarning(pos, msg
            +"\nLeft type = " + Type.removesBoolAndInt(left.type)
            +"\nRight type = " + Type.removesBoolAndInt(right.type));
   }

View Full Code Here


   /** Convenience method that generates a type warning with "msg" as the message,
    * and includes the parent's relevance type, as well as the left and right bounding types in the message.
    */
   private ErrorWarning warn(String msg, Type parent) {
      return new ErrorWarning(pos, msg
         + "\nParent's relevant type = " + Type.removesBoolAndInt(parent)
         + "\nLeft type = " + Type.removesBoolAndInt(left.type)
         + "\nRight type = " + Type.removesBoolAndInt(right.type));
   }

View Full Code Here

   //============================================================================================================//


   /** {@inheritDoc} */
   @Override public Expr resolve(Type p, Collection<ErrorWarning> warns) {
      if (errors.size()>0) return this;
      ErrorWarning w=null;
      Type a=left.type, b=right.type;
      switch(op) {
        case MUL: case DIV: case REM: case LT: case LTE: case GT: case GTE: case SHL: case SHR: case SHA:
        case NOT_LTE: case NOT_GTE: case NOT_LT: case NOT_GT: {
           a=(b=Type.INT);

View Full Code Here

    //============================================================================================================//


    /** {@inheritDoc} */
    @Override public Expr resolve(Type p, Collection<ErrorWarning> warns) {
        if (errors.size()>0) return this;
        ErrorWarning w1=null, w2=null;
        Type s=p;
        switch(op) {
          case NOT:
            s=Type.FORMULA;
            break;
          case TRANSPOSE: case RCLOSURE: case CLOSURE:
            if (warns!=null && op!=Op.TRANSPOSE && type.join(type).hasNoTuple())
               w1=new ErrorWarning(pos, this+" is redundant since its domain and range are disjoint: "+sub.type.extract(2));
            s = (op!=Op.TRANSPOSE) ? resolveClosure(p, sub.type) : sub.type.transpose().intersect(p).transpose() ;
            if (warns!=null && s==EMPTY && p.hasTuple())
               w2=new ErrorWarning(sub.span(),
               "The value of this expression does not contribute to the value of the parent.\nParent's relevant type = "
               +p+"\nThis expression's type = "+sub.type.extract(2));
            break;
          case CARDINALITY: case NO: case ONE: case SOME: case LONE:
            s=Type.removesBoolAndInt(sub.type);
            break;
          case CAST2SIGINT:
            s=Type.INT;
            break;
          case CAST2INT:
            s=sub.type.intersect(SIGINT.type);
            if (warns!=null && s.hasNoTuple())
               w1=new ErrorWarning(sub.span(),
               "This expression should contain Int atoms.\nInstead, its possible type(s) are:\n"+sub.type.extract(1));
            break;
        }
        Expr sub = this.sub.resolve(s, warns);
        if (w1!=null) warns.add(w1);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of edu.mit.csail.sdg.alloy4.Pos

edu.mit.csail.sdg.alloy4compiler.ast.Expr

edu.mit.csail.sdg.alloy4compiler.ast.ExprBinary

edu.mit.csail.sdg.alloy4compiler.ast.ExprCall

edu.mit.csail.sdg.alloy4compiler.ast.ExprChoice

edu.mit.csail.sdg.alloy4compiler.ast.ExprITE

edu.mit.csail.sdg.alloy4compiler.ast.ExprLet

edu.mit.csail.sdg.alloy4compiler.ast.ExprList

edu.mit.csail.sdg.alloy4compiler.ast.ExprQt

edu.mit.csail.sdg.alloy4compiler.ast.Func

edu.mit.csail.sdg.alloy4compiler.ast.Sig

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.