public DataType VisitFieldAccess(AttributeAccess a) { // the form of ::A in ruby if (a.Expression == null) { return(a.FieldName.Accept(this)); } DataType targetType = a.Expression.Accept(this); if (targetType is UnionType) { ISet <DataType> types = ((UnionType)targetType).types; DataType retType = DataType.Unknown; foreach (DataType tt in types) { retType = UnionType.Union(retType, getAttrType(a, tt)); } return(retType); } else { return(getAttrType(a, targetType)); } }
public void addRef(AttributeAccess attr, DataType targetType, ISet <Binding> bs) { foreach (Binding b in bs) { putRef(attr, b); if (attr.Parent is Application && b.Type is FunType && targetType is InstanceType) { // method call ((FunType)b.Type).SelfType = targetType; } } }
public static string[] GetMemberNames(AttributeAccess attributeAccess) { string[] methodNames = GetMemberNames(attributeAccess.Qualifier); List <string> names = new List <string>(); names.AddRange(methodNames); string lastMemberName = attributeAccess.Name.Substring(0, attributeAccess.Name.Length - 1); names.Add(lastMemberName); return(names.ToArray()); }
private static void setAttrType(Analyzer analyzer, AttributeAccess attr, DataType targetType, DataType attrType) { if (targetType.isUnknownType()) { analyzer.putProblem(attr, "Can't set attribute for UnknownType"); return; } ISet <Binding> bs = targetType.Table.LookupAttribute(attr.FieldName.Name); if (bs != null) { analyzer.addRef(attr, targetType, bs); } targetType.Table.Insert(analyzer, attr.FieldName.Name, attr, attrType, BindingKind.ATTRIBUTE); }
private static void setAttr(Analyzer analyzer, AttributeAccess attr, DataType attrType, DataType targetType) { if (targetType is UnionType) { ISet <DataType> types = ((UnionType)targetType).types; foreach (DataType tp in types) { setAttrType(analyzer, attr, tp, attrType); } } else { setAttrType(analyzer, attr, targetType, attrType); } }
public DataType GetAttrType(AttributeAccess a, DataType targetType) { ISet <Binding> bs = targetType.Table.LookupAttribute(a.FieldName.Name); if (bs == null) { analyzer.putProblem(a.FieldName, "attribute not found in type: " + targetType); DataType t = DataType.Unknown; t.Table.Path = targetType.Table.ExtendPath(analyzer, a.FieldName.Name); return(t); } else { analyzer.addRef(a, targetType, bs); return(State.MakeUnion(bs)); } }
private static void FoldLastOperands(ref List <Expr> operands, Token op) { Expr leftOperand = operands[operands.Count - 2]; Expr rightOperand = operands[operands.Count - 1]; Expr operation; if (op.Type == TokenInfo.TokenType.DOT) { operation = new AttributeAccess(leftOperand, rightOperand); } else { operation = new InfixOp(leftOperand, rightOperand, op); } operands.RemoveAt(operands.Count - 1); operands.RemoveAt(operands.Count - 1); operands.Add(operation); }
void WalkSimpleAssignment(SimpleAssignmentExpression node) { AttributeAccess attributeAccess = node.Left as AttributeAccess; InstanceVariable instance = node.Left as InstanceVariable; LocalVariable localVariable = node.Left as LocalVariable; if (attributeAccess != null) { RubyControlFieldExpression field = RubyControlFieldExpression.Create(attributeAccess); object propertyValue = deserializer.Deserialize(node.Right); if (propertyValue != null) { field.SetPropertyValue(componentCreator, propertyValue); } else if (IsResource(node.Right)) { field.SetPropertyValue(componentCreator, GetResource(node.Right as MethodCall)); } else { ThrowCouldNotFindTypeException(node.Right); } } else if (instance != null) { string instanceName = RubyControlFieldExpression.GetVariableName(instance.Name); object propertyValue = deserializer.Deserialize(instanceName, node.Right); AddComponent(instanceName, propertyValue); } else if (localVariable != null) { object propertyValue = deserializer.Deserialize(localVariable.Name, node.Right); if (propertyValue == null) { ThrowCouldNotFindTypeException(node.Right); } } }
public CodeExpression VisitFieldAccess(AttributeAccess acc) { var exp = acc.Expression.Accept(this); return(m.Access(exp, acc.FieldName.Name)); }
public void VisitFieldAccess(AttributeAccess acc) { throw new NotImplementedException(); }
public void addRef(AttributeAccess attr, DataType targetType, ISet<Binding> bs) { foreach (Binding b in bs) { putRef(attr, b); if (attr.Parent != null && attr.Parent is Application && b.type is FunType && targetType is InstanceType) { // method call ((FunType) b.type).SelfType = targetType; } } }
public void VisitFieldAccess(AttributeAccess acc) { throw new NotImplementedException(); }
/// <summary> /// Creates a RubyControlField from an attribute access expression: /// /// @textBox1.Name = /// self.textBox1 = /// self.textBox1.Name = /// </summary> public static RubyControlFieldExpression Create(AttributeAccess expression) { return(Create(GetMemberNames(expression))); }
private static void setAttrType(Analyzer analyzer, AttributeAccess attr, DataType targetType, DataType attrType) { if (targetType.isUnknownType()) { analyzer.putProblem(attr, "Can't set attribute for UnknownType"); return; } ISet<Binding> bs = targetType.Table.LookupAttribute(attr.FieldName.Name); if (bs != null) { analyzer.addRef(attr, targetType, bs); } targetType.Table.Insert(analyzer, attr.FieldName.Name, attr, attrType, BindingKind.ATTRIBUTE); }
private static void setAttr(Analyzer analyzer, AttributeAccess attr, DataType attrType, DataType targetType) { if (targetType is UnionType) { ISet<DataType> types = ((UnionType) targetType).types; foreach (DataType tp in types) { setAttrType(analyzer, attr, tp, attrType); } } else { setAttrType(analyzer, attr, targetType, attrType); } }