def scopeAndType = ModelReference.of(String).inScope(ModelPath.path("scope"))

        Matchers.strictlyEquals(path, ModelReference.of("path"))
        Matchers.strictlyEquals(type, ModelReference.of(String))
        Matchers.strictlyEquals(pathAndType, ModelReference.of("path", String))
        Matchers.strictlyEquals(scopeAndType, type.inScope(ModelPath.path("scope")))

        path != type

#     # and LessThan at PRODUCT.PRODUCT_NAME and PRODUCT.PRODUCT_HANDLE_CODE,
#     # and InScope for LONGVARCHAR(e.g. text type) is excluded.
#     ; String = map:{
#         ; GreaterThan = map:{ MEMBER = list:{ MEMBER_ACCOUNT } }
#         ; LessThan = map:{ PRODUCT = list:{ PRODUCT_NAME ; PRODUCT_HANDLE_CODE } }
#         ; !InScope = map:{ $$ALL$$ = list:{ type:LONGVARCHAR } }
#     }

                ktClassOrObject.getClassId() == classId && ktClassOrObject.inScope
            }
            ?: emptyList()

    override fun getAllTypeAliasesByClassId(classId: ClassId): Collection<KtTypeAlias> =
        index.typeAliasMap[classId.packageFqName]
            ?.filter { ktTypeAlias ->
                ktTypeAlias.getClassId() == classId && ktTypeAlias.inScope
            }
            ?: emptyList()

        binder {
            descriptor("ruleWithUnboundSubjectReference")
            subjectReference(ModelReference.of(String).inScope(ModelPath.path("some.scope")))
            inputReference(String)
            inputReference(ModelReference.of(Boolean).inScope(ModelPath.path("other.scope")))
        }

        expect:
        reportForProcessedBinders == reportFor(

        }

        void inputReference(Class type) {
            inputReference(ModelReference.of(ModelType.of(type)).inScope(ModelPath.ROOT))
        }

        void inputReference(Class type, ModelNode.State state) {
            inputReference(ModelReference.of(null, ModelType.of(type), state).inScope(ModelPath.ROOT))
        }

        void inputReference(String path, ModelNode.State state) {

    }

    RuleBinder rule(Class subjectType, ModelNode.State targetState) {
        def builder = new RuleBinderTestBuilder()
        builder.subjectReference(ModelReference.of(null, ModelType.of(subjectType), targetState).inScope(ModelPath.ROOT))
        builder.descriptor("rule with subject of type $subjectType.simpleName")
        return builder.build()
    }

    }

    private static <T> ModelReference<T> subject(ModelPath path, ModelType<T> type) {
        return path != null ? ModelReference.of(path, type) : ModelReference.of(type).inScope(ModelPath.ROOT);
    }

    }

    public ModelNode.State getState() {
        return state;
    }

    public boolean isUntyped() {
        return type.equals(ModelType.UNTYPED);
    }

    public ModelReference<T> inScope(ModelPath scope) {
        if (scope.equals(this.scope)) {
            return this;
        }
        return Cast.uncheckedCast(new ModelReference<T>(path, type, scope, state, description));
    }

	if !strOk && !errOk {
		return "", false
	}

	// inScope returns true if e is in the scope of f.
	inScope := func(e ast.Expr, f *types.Func) bool {
		return f.Scope() != nil && f.Scope().Contains(e.Pos())
	}

	// Is the expression e within the body of that String or Error method?
	var method *types.Func
	if strOk && strMethod.Pkg() == pass.Pkg && inScope(e, strMethod) {
		method = strMethod

                } else {
                    inputs.set(i, input.inScope(ModelPath.ROOT));
                }
            }
        }

        private ModelReference<?> mapSubject(ModelReference<?> subject, ModelPath targetPath) {
            if (subject.getPath() == null) {
                return subject.inScope(targetPath);
            } else {