static private final NameBinder DEFAULT_BINDER = new NameBinder();

static private final NameBinder ATTRIBUTE_BINDER = new NameBinder(ATTRIBUTE);

static private final NameBinder CLASS_BINDER = new NameBinder(CLASS);

static private final NameBinder CONSTRUCTOR_BINDER = new NameBinder(CONSTRUCTOR);

static private final NameBinder FUNCTION_BINDER = new NameBinder(FUNCTION);

static private final NameBinder METHOD_BINDER = new NameBinder(METHOD);

static private final NameBinder MODULE_BINDER = new NameBinder(MODULE);

static private final NameBinder PARAMETER_BINDER = new NameBinder(PARAMETER);

static private final NameBinder VARIABLE_BINDER = new NameBinder(VARIABLE);

private NBinding.Kind kind;

/**

public static NameBinder make() {

return DEFAULT_BINDER;

}

/**

public static NameBinder make(NBinding.Kind kind) {

switch (kind) {

case ATTRIBUTE:

return ATTRIBUTE_BINDER;

case CLASS:

return CLASS_BINDER;

case CONSTRUCTOR:

return CONSTRUCTOR_BINDER;

case FUNCTION:

return FUNCTION_BINDER;

case METHOD:

return METHOD_BINDER;

case MODULE:

return MODULE_BINDER;

case PARAMETER:

return PARAMETER_BINDER;

case VARIABLE:

return VARIABLE_BINDER;

default:

return DEFAULT_BINDER;

}

}

private NameBinder() {

}

private NameBinder(NBinding.Kind kind) {

this.kind = kind;

}

public void bind(Scope s, NNode target, NType rvalue) throws Exception {

if (target instanceof NName) {

bindName(s, (NName)target, rvalue);

return;

}

if (target instanceof NTuple) {

bind(s, ((NTuple)target).elts, rvalue);

return;

}

if (target instanceof NList) {

bind(s, ((NList)target).elts, rvalue);

return;

}

if (target instanceof NAttribute) {

// This causes various problems if we let it happen during the

// name-binding pass. I believe the only name-binding context

// in which an NAttribute can be an lvalue is in an assignment.

// Assignments are statements, so they can only appear in blocks.

// Hence the scope for the top-level name is unambiguous; we can

// safely leave binding it until the resolve pass.

if (!s.isNameBindingPhase()) {

((NAttribute)target).setAttr(s, rvalue);

}

return;

}

if (target instanceof NSubscript) {

// Ditto. No resolving is allowed during the name-binding phase.

if (!s.isNameBindingPhase()) {

target.resolveExpr(target, s);

}

return;

}

Indexer.idx.putProblem(target, "invalid location for assignment");

}

public void bind(Scope s, List<NNode> xs, NType rvalue) throws Exception {

if (rvalue.isTupleType()) {

List<NType> vs = rvalue.asTupleType().getElementTypes();

if (xs.size() != vs.size()) {

reportUnpackMismatch(xs, vs.size());

} else {

for (int i = 0; i < xs.size(); i++) {

bind(s, xs.get(i), vs.get(i));

}

}

return;

}

if (rvalue.isListType()) {

bind(s, xs, rvalue.asListType().toTupleType(xs.size()));

return;

}

if (rvalue.isDictType()) {

bind(s, xs, rvalue.asDictType().toTupleType(xs.size()));

return;

}

if (!rvalue.isUnknownType()) {

Indexer.idx.putProblem(xs.get(0).getFile(),

xs.get(0).start(),

xs.get(xs.size()-1).end(),

"unpacking non-iterable: " + rvalue);

}

for (int i = 0; i < xs.size(); i++) {

bind(s, xs.get(i), new NUnknownType());

}

}

public NBinding bindName(Scope s, NName name, NType rvalue) throws Exception {

NBinding b;

if (s.isGlobalName(name.id)) {

b = s.getGlobalTable().put(name.id, name, rvalue, kindOr(SCOPE));

Indexer.idx.putLocation(name, b);

} else {

Scope bindingScope = s.getScopeSymtab();

b = bindingScope.put(name.id, name, rvalue,

kindOr(bindingScope.isFunctionScope() ? VARIABLE : SCOPE));

}

name.setType(b.followType());

// XXX: this seems like a bit of a hack; should at least figure out

// and document what use cases require it.

NType nameType = name.getType();

if (!(nameType.isModuleType() || nameType.isClassType())) {

nameType.getTable().setPath(b.getQname());

}

return b;

}

public void bindIter(Scope s, NNode target, NNode iter) throws Exception {

NType iterType = NNode.resolveExpr(iter, s);

if (iterType.isListType()) {

bind(s, target, iterType.asListType().getElementType());

} else if (iterType.isTupleType()) {

bind(s, target, iterType.asTupleType().toListType().getElementType());

} else {

NBinding ent = iterType.getTable().lookupAttr("__iter__");

if (ent == null || !ent.getType().isFuncType()) {

if (!iterType.isUnknownType()) {

iter.addWarning("not an iterable type: " + iterType);

}

bind(s, target, new NUnknownType());

} else {

bind(s, target, ent.getType().asFuncType().getReturnType());

}

}

}

private void reportUnpackMismatch(List<NNode> xs, int vsize) {

int xsize = xs.size();

int beg = xs.get(0).start();

int end = xs.get(xs.size() - 1).end();

int diff = xsize - vsize;

String msg;

if (diff > 0) {

msg = "ValueError: need more than " + vsize + " values to unpack";

} else {

msg = "ValueError: too many values to unpack";

}

Indexer.idx.putProblem(xs.get(0).getFile(), beg, end, msg);

}

private NBinding.Kind kindOr(NBinding.Kind k) {

return kind != null ? kind : k;

}