Question

以下代码块定义了我的custom JVM programming language的编译器如何解析缺少的抽象方法并将方法链接到它们的超类型方法。继承模型与Java 8类似，您可以在接口和抽象类中使用抽象和具体（默认）方法，并且只在非抽象类中使用具体方法。显然，只有接口允许多重继承：

CodeClass.java：

public class CodeClass extends AbstractClass
{
    // ...
    public void checkTypes(MarkerList markers, IContext context)
    {
        // ...
        if (this.superType != null)
        {
            this.superType.getTheClass().checkMethods(markers, this, this.superType);
        }
        for (int i = 0; i < this.interfaceCount; i++)
        {
            IType type = this.interfaces[i];
            type.getTheClass().checkMethods(markers, this, type);
        }
    }
    // ...
}

AbstractClass.java：

public class AbstractClass
{
    protected ClassBody body;

    // ...        

    public boolean checkImplements(MarkerList markers, IClass iclass, IMethod candidate, ITypeContext typeContext)
    {
        if (candidate.getTheClass() == this)
        {
            return !candidate.hasModifier(Modifiers.ABSTRACT);
        }

        if (this.body != null && this.body.checkImplements(markers, iclass, candidate, typeContext))
        {
            return true;
        }

        if (this.superType != null)
        {
            if (this.superType.getTheClass().checkImplements(markers, iclass, candidate, this.superType.getConcreteType(typeContext)))
            {
                return true;
            }
        }

        for (int i = 0; i < this.interfaceCount; i++)
        {
            IType type = this.interfaces[i];
            if (type.getTheClass().checkImplements(markers, iclass, candidate, type.getConcreteType(typeContext)))
            {
                return true;
            }
        }

        return false;
    }

    public void checkMethods(MarkerList markers, IClass iclass, ITypeContext typeContext)
    {
        if (this.body != null)
        {
            this.body.checkMethods(markers, iclass, typeContext);
        }

        if (this.superType != null)
        {
            this.superType.getTheClass().checkMethods(markers, iclass, this.superType.getConcreteType(typeContext));
        }
        for (int i = 0; i < this.interfaceCount; i++)
        {
            IType type = this.interfaces[i];
            type.getTheClass().checkMethods(markers, iclass, type.getConcreteType(typeContext));
        }
    }
    // ...
}

ClassBody.java：

public class ClassBody
{
    // ...

    public boolean checkImplements(MarkerList markers, IClass iclass, IMethod candidate, ITypeContext typeContext)
    {
        for (int i = 0; i < this.methodCount; i++)
        {
            if (this.methods[i].checkOverride(markers, iclass, candidate, typeContext))
            {
                return true;
            }
        }
        return false;
    }

    public void checkMethods(MarkerList markers, IClass iclass, ITypeContext typeContext)
    {
        for (int i = 0; i < this.methodCount; i++)
        {
            IMethod candidate = this.methods[i];
            if (iclass.checkImplements(markers, iclass, candidate, typeContext))
            {
                continue;
            }

            if (candidate.hasModifier(Modifiers.ABSTRACT) && !iclass.hasModifier(Modifiers.ABSTRACT))
            {
                markers.add(iclass.getPosition(), "class.method.abstract", iclass.getName(), candidate.getName(), this.theClass.getName());
            }
        }
    }

    // ...
}

method.checkOverride只是检查候选者和接收者的签名是否匹配，如果iclass参数和方法的容器类是同一类型，则候选者被添加到列表中覆盖方法。

这段代码非常漂亮，而且我的工作方式也很有效，但是我担心它会因为很多方法（比如集合框架）而深深陷入深层次的层次结构，因为整个过程都是一个强大的递归操作，需要检查很多很多类型，并反复遍历方法数组。对于大类树是否有一个不那么复杂且性能更高的解决方案，其他编译器（例如javac或scalac）如何解决这个问题呢？

改进覆盖/抽象方法分辨率算法

0 个答案: