public Binding(string id, Node node, DataType type, BindingKind kind) { this.name = id; this.qname = type.Table.Path; this.type = type; this.kind = kind; this.node = node; this.References = new HashSet <Node>(); if (node is Url u) { string url = u.url; if (url.StartsWith("file://")) { fileOrUrl = url.Substring("file://".Length); } else { fileOrUrl = url; } } else { fileOrUrl = node.Filename; if (node is Identifier idNode) { name = node.Name; } } SetLocationInfo(node); }
/// <summary> /// Bind a name to this scope, including destructuring assignment. /// </summary> public void Bind(Analyzer analyzer, Exp target, DataType rvalue, BindingKind kind) { if (target is Identifier id) { this.Bind(analyzer, id, rvalue, kind); } else if (target is PyTuple tup) { this.Bind(analyzer, tup.values, rvalue, kind); } else if (target is PyList list) { this.Bind(analyzer, list.elts, rvalue, kind); } else if (target is AttributeAccess attr) { DataType targetType = TransformExp(analyzer, attr.Expression, this); setAttr(analyzer, attr, rvalue, targetType); } else if (target is ArrayRef sub) { DataType valueType = TransformExp(analyzer, sub.array, this); var xform = new TypeTransformer(this, analyzer); TransformExprs(analyzer, sub.subs, this); if (valueType is ListType t) { t.setElementType(UnionType.Union(t.eltType, rvalue)); } } else if (target != null) { analyzer.putProblem(target, "invalid location for assignment"); } }
public Binding CreateBinding(string id, Node node, DataType type, BindingKind kind) { var b = new Binding(id, node, type, kind); RegisterBinding(b); return(b); }
static void AddReadOnlyAttr( Analyzer analyzer, FunType fun, string name, DataType type, BindingKind kind) { Node loc = Builtins.newDataModelUrl("the-standard-type-hierarchy"); Binding b = analyzer.CreateBinding(name, loc, type, kind); fun.Table.Update(name, b); b.IsSynthetic = true; b.IsStatic = true; }
public Binding Insert(Analyzer analyzer, string id, Exp node, DataType type, BindingKind kind) { Binding b = analyzer.CreateBinding(id, node, type, kind); if (type is ModuleType) { b.qname = type.asModuleType().qname; } else { b.qname = ExtendPath(analyzer, id); } Update(id, b); return(b); }
public void Bind(Analyzer analyzer, List <Exp> xs, DataType rvalue, BindingKind kind) { switch (rvalue) { case TupleType tuple: { List <DataType> vs = tuple.eltTypes; if (xs.Count != vs.Count) { ReportUnpackMismatch(analyzer, xs, vs.Count); } else { for (int i = 0; i < xs.Count; i++) { this.Bind(analyzer, xs[i], vs[i], kind); } } break; } case ListType list: Bind(analyzer, xs, list.toTupleType(xs.Count), kind); break; case DictType dict: Bind(analyzer, xs, dict.ToTupleType(xs.Count), kind); break; default: if (rvalue.isUnknownType()) { foreach (Exp x in xs) { this.Bind(analyzer, x, DataType.Unknown, kind); } break; } else if (xs.Count > 0) { analyzer.AddProblem(xs[0].Filename, xs[0].Start, xs[xs.Count - 1].End, "unpacking non-iterable: " + rvalue); } break; } }
public void Bind(Analyzer analyzer, Identifier id, DataType rvalue, BindingKind kind) { if (this.IsGlobalName(id.Name)) { ISet <Binding> bs = this.Lookup(id.Name); if (bs != null) { foreach (Binding b in bs) { b.addType(rvalue); analyzer.putRef(id, b); } } } else { this.Insert(analyzer, id.Name, id, rvalue, kind); } }
public void Bind(Analyzer analyzer, List <Exp> xs, DataType rvalue, BindingKind kind) { if (rvalue is TupleType) { List <DataType> vs = ((TupleType)rvalue).eltTypes; if (xs.Count != vs.Count) { ReportUnpackMismatch(analyzer, xs, vs.Count); } else { for (int i = 0; i < xs.Count; i++) { this.Bind(analyzer, xs[i], vs[i], kind); } } } else { if (rvalue is ListType) { Bind(analyzer, xs, ((ListType)rvalue).toTupleType(xs.Count), kind); } else if (rvalue is DictType) { Bind(analyzer, xs, ((DictType)rvalue).ToTupleType(xs.Count), kind); } else if (rvalue.isUnknownType()) { foreach (Exp x in xs) { this.Bind(analyzer, x, DataType.Unknown, kind); } } else if (xs.Count > 0) { analyzer.putProblem(xs[0].Filename, xs[0].Start, xs[xs.Count - 1].End, "unpacking non-iterable: " + rvalue); } } }
/// <summary> /// Bind a name to this scope, including destructuring assignment. /// </summary> public void Bind(Analyzer analyzer, Exp target, DataType rvalue, BindingKind kind) { switch (target) { case Identifier id: this.Bind(analyzer, id, rvalue, kind); break; case PyTuple tup: this.Bind(analyzer, tup.values, rvalue, kind); break; case PyList list: this.Bind(analyzer, list.elts, rvalue, kind); break; case AttributeAccess attr: DataType targetType = TransformExp(analyzer, attr.Expression, this); setAttr(analyzer, attr, rvalue, targetType); break; case ArrayRef sub: DataType valueType = TransformExp(analyzer, sub.array, this); var xform = new TypeTransformer(this, analyzer); TransformExprs(analyzer, sub.subs, this); if (valueType is ListType t) { t.setElementType(UnionType.Union(t.eltType, rvalue)); } break; default: if (target != null) { analyzer.AddProblem(target, "invalid location for assignment"); } break; } }
/// <summary> /// Bind a name to this scope, including destructuring assignment. /// </summary> public void Bind(Analyzer analyzer, Exp target, DataType rvalue, BindingKind kind) { if (target is Identifier) { this.Bind(analyzer, (Identifier)target, rvalue, kind); } else if (target is PyTuple) { this.Bind(analyzer, ((PyTuple)target).values, rvalue, kind); } else if (target is PyList) { this.Bind(analyzer, ((PyList)target).elts, rvalue, kind); } else if (target is AttributeAccess) { var attr = (AttributeAccess)target; DataType targetType = transformExpr(analyzer, attr.Expression, this); setAttr(analyzer, attr, rvalue, targetType); } else if (target is ArrayRef) { ArrayRef sub = (ArrayRef)target; DataType valueType = transformExpr(analyzer, sub.array, this); var xform = new TypeTransformer(this, analyzer); transformExprs(analyzer, sub.subs, this); if (valueType is ListType) { ListType t = (ListType)valueType; t.setElementType(UnionType.Union(t.eltType, rvalue)); } } else if (target != null) { analyzer.putProblem(target, "invalid location for assignment"); } }
public void Bind(Analyzer analyzer, List<Exp> xs, DataType rvalue, BindingKind kind) { if (rvalue is TupleType) { List<DataType> vs = ((TupleType) rvalue).eltTypes; if (xs.Count != vs.Count) { ReportUnpackMismatch(analyzer, xs, vs.Count); } else { for (int i = 0; i < xs.Count; i++) { this.Bind(analyzer, xs[i], vs[i], kind); } } } else { if (rvalue is ListType) { Bind(analyzer, xs, ((ListType) rvalue).toTupleType(xs.Count), kind); } else if (rvalue is DictType) { Bind(analyzer, xs, ((DictType) rvalue).toTupleType(xs.Count), kind); } else if (rvalue.isUnknownType()) { foreach (Exp x in xs) { this.Bind(analyzer, x, DataType.Unknown, kind); } } else if (xs.Count > 0) { analyzer.putProblem(xs[0].Filename, xs[0].Start, xs[xs.Count - 1].End, "unpacking non-iterable: " + rvalue); } } }
// iterator public void BindIterator(Analyzer analyzer, Exp target, Exp iter, DataType iterType, BindingKind kind) { if (iterType is ListType) { this.Bind(analyzer, target, ((ListType) iterType).eltType, kind); } else if (iterType is TupleType) { this.Bind(analyzer, target, ((TupleType) iterType).toListType().eltType, kind); } else { ISet<Binding> ents = iterType.Table.LookupAttribute("__iter__"); if (ents != null) { foreach (Binding ent in ents) { if (ent == null || !(ent.type is FunType)) { if (!iterType.isUnknownType()) { analyzer.putProblem(iter, "not an iterable type: " + iterType); } this.Bind(analyzer, target, DataType.Unknown, kind); } else { this.Bind(analyzer, target, ((FunType) ent.type).getReturnType(), kind); } } } else { this.Bind(analyzer, target, DataType.Unknown, kind); } } }
public ConstBindingViewModel(BindingKind kind, int value) { Kind = kind; Value = value; }
protected void update(string name, Url url, DataType type, BindingKind kind) { table.Insert(outer.analyzer, name, url, type, kind).IsBuiltin = true; }
public Binding Insert(Analyzer analyzer, string id, Exp node, DataType type, BindingKind kind) { Binding b = analyzer.CreateBinding(id, node, type, kind); if (type is ModuleType) { b.qname = type.asModuleType().qname; } else { b.qname = extendPath(analyzer, id); } Update(id, b); return b; }
public void Bind(Analyzer analyzer, Identifier id, DataType rvalue, BindingKind kind) { if (this.IsGlobalName(id.Name)) { ISet<Binding> bs = this.Lookup(id.Name); if (bs != null) { foreach (Binding b in bs) { b.addType(rvalue); analyzer.putRef(id, b); } } } else { this.Insert(analyzer, id.Name, id, rvalue, kind); } }
// iterator public void BindIterator(Analyzer analyzer, Exp target, Exp iter, DataType iterType, BindingKind kind) { if (iterType is ListType list) { this.Bind(analyzer, target, list.eltType, kind); } else if (iterType is TupleType tuple) { this.Bind(analyzer, target, tuple.ToListType().eltType, kind); } else { ISet <Binding>?ents = iterType.Table.LookupAttribute("__iter__"); if (ents != null) { foreach (Binding ent in ents) { if (!(ent?.Type is FunType fun)) { if (!iterType.IsUnknownType()) { analyzer.AddProblem(iter, "not an iterable type: " + iterType); } this.Bind(analyzer, target, DataType.Unknown, kind); } else { this.Bind(analyzer, target, fun.GetReturnType(), kind); } } }
public Binding Insert(Analyzer analyzer, string id, Module node, DataType type, BindingKind kind) { Binding b = analyzer.CreateBinding(id, node, type, kind); if (type is ModuleType mt) { b.qname = mt.qname; } else { b.qname = analyzer.ExtendPath(this.Path, id); } Update(id, b); return(b); }
public BindingViewModel(BindingKind kind, FieldViewModel source, FieldViewModel target) { Kind = kind; Source = source; Target = target; }
public Binding CreateBinding(string id, Node node, DataType type, BindingKind kind) { var b = new Binding(id, node, type, kind); RegisterBinding(b); return b; }
// iterator public void BindIterator(Analyzer analyzer, Exp target, Exp iter, DataType iterType, BindingKind kind) { if (iterType is ListType) { this.Bind(analyzer, target, ((ListType)iterType).eltType, kind); } else if (iterType is TupleType) { this.Bind(analyzer, target, ((TupleType)iterType).ToListType().eltType, kind); } else { ISet <Binding> ents = iterType.Table.LookupAttribute("__iter__"); if (ents != null) { foreach (Binding ent in ents) { if (ent == null || !(ent.type is FunType)) { if (!iterType.isUnknownType()) { analyzer.putProblem(iter, "not an iterable type: " + iterType); } this.Bind(analyzer, target, DataType.Unknown, kind); } else { this.Bind(analyzer, target, ((FunType)ent.type).GetReturnType(), kind); } } } else { this.Bind(analyzer, target, DataType.Unknown, kind); } } }
/// <summary> /// Bind a name to this scope, including destructuring assignment. /// </summary> public void Bind(Analyzer analyzer, Exp target, DataType rvalue, BindingKind kind) { if (target is Identifier) { this.Bind(analyzer, (Identifier) target, rvalue, kind); } else if (target is PyTuple) { this.Bind(analyzer, ((PyTuple) target).values, rvalue, kind); } else if (target is PyList) { this.Bind(analyzer, ((PyList) target).elts, rvalue, kind); } else if (target is AttributeAccess) { var attr = (AttributeAccess) target; DataType targetType = transformExpr(analyzer, attr.Expression, this); setAttr(analyzer, attr, rvalue, targetType); } else if (target is ArrayRef) { ArrayRef sub = (ArrayRef) target; DataType valueType = transformExpr(analyzer, sub.array, this); var xform = new TypeTransformer(this, analyzer); transformExprs(analyzer, sub.subs, this); if (valueType is ListType) { ListType t = (ListType) valueType; t.setElementType(UnionType.Union(t.eltType, rvalue)); } } else if (target != null) { analyzer.putProblem(target, "invalid location for assignment"); } }