slcom/slangc/model/MethodModel.sauce

package slangc.model;

import slang.data.List;
import slangc.api.Reporter;
import slangc.bytecode.MethodSignature;
import slangc.bytecode.TypeSignature;
import slangc.model.clauses.Arguments;
import slangc.model.expressions.SuperConstructorCallExpression;
import slangc.model.expressions.ThisConstructorCallExpression;
import slangc.model.statements.BlockStatement;
import slangc.model.statements.ExpressionStatement;
import slangc.parser.Branch;
import slangc.parser.ErrorType;
import slangc.parser.Node;
import slangc.parser.NodeType;

public class MethodModel extends MemberModel implements StatementOwner {
	BlockStatement body = null;
	ParameterSet parameters = null;
	TypeModel returnType = null;
	TypeModel[] exceptions = null;
	List<LocalStorageModel> locals = null;
	MethodModel prototype = null;

	/** Constructor for synthetic methods which copy an existing method signature. */
	public MethodModel(TypeModel owner, String name, MethodModel copySignatureFrom) {
		super(owner, name, null);
		// TODO: It might be worth making a deep copy of the parameters so they're actually usable by synthetic code
		parameters = copySignatureFrom.parameters;
		returnType = copySignatureFrom.returnType;
		exceptions = copySignatureFrom.exceptions;
		setAttributes(copySignatureFrom.getAttributes());
		this.prototype = copySignatureFrom;
	}
	
	public MethodModel(TypeModel owner, String name, Branch source) {
		super(owner, name, source);
		
		parameters = new ParameterSet(this);
		
		if (!isStaticInitialisation()) {
			Branch p = source.getNodeType() == NodeType.METHOD_DECLARATION ?
					(Branch) source.getSubnode(source.countSubnodes() - 4)
					: (Branch) source.getSubnode(source.countSubnodes() - 3);
			Branch l = (Branch) p.getSubnode(1);
			int goodparams = 0;
			for (int i = 0; i < l.countSubnodes(); i++) {
				Node n = l.getSubnode(i);
				if (n.getNodeType() != NodeType.COMMA) {
					goodparams++;
				}
			}
			for (int i = 0; i < l.countSubnodes(); i++) {
				/* Parameters are indexed in bytecode by their stack position (relative to
				 * the method call frame info), which gives the last parameter index -1,
				 * the second-last index -2 and so on (since the last parameter will be
				 * pushed just before the method call frame starts).
				 */
				int negindex = (0 - goodparams) + parameters.countParameters();
				Node n = l.getSubnode(i);
				if (n.getNodeType() != NodeType.COMMA) {
					parameters.addParameter(new ParameterModel(this, negindex /*parameters.countParameters()*/, (Branch) n));
				}
			}
			exceptions = unpackExceptions(((Branch)(source.getSubnode(source.countSubnodes() - 2))));
		}
		
		if (isConstructor()) {
			//Log.line("Owner is " + owner.fullName());
			returnType = owner;
		} else if (isStaticInitialisation()) {
			returnType = null; // TODO: Better "void" handling
		} else {
			Branch t = (Branch) source.getSubnode(2);
			if (t.getNodeType() == NodeType.NO_RETURN_TYPE) {
				returnType = null; // TODO: Better "void" handling
			} else {
				returnType = ((UserTypeModel)owner).resolveTypeReference(t.getSubnode(0));
			}
		}

		if (hasBody()) {
			body = new BlockStatement(this, (Branch) ((Branch)(source.getSubnode(source.countSubnodes() - 1))).getSubnode(0));
		}
		
	}
	
	private TypeModel[] unpackExceptions(Branch b) {
		if (b.getNodeType() == NodeType.NO_THROWS) {
			return null;
		} else {
			Branch list = (Branch)b.getSubnode(0);
			if (list.countSubnodes() == 0) {
				return null;
			}
			int count = 0;
			for (int i = 0; i < list.countSubnodes(); i++) {
				if (list.getSubnode(i).getNodeType() != NodeType.COMMA) {
					count++;
				}
			}
			TypeModel[] result = new TypeModel[count];
			count = 0;
			for (int i = 0; i < list.countSubnodes(); i++) {
				if (list.getSubnode(i).getNodeType() != NodeType.COMMA) {
					result[count] = getOwner().resolveTypeReference(list.getSubnode(i));
					if (result[count] == null) {
						list.getSubnode(i).annotate(ErrorType.INTERNAL_ERROR, "Failed to resolve type reference");
						//throw new Error("TODO  BAD");
					}
					count++;
				}
			}
			return result;
		}
	}
	
	public int countExceptions() {
		if (exceptions == null) {
			return 0;
		} else {
			return exceptions.length;
		}
	}
	
	public TypeModel getException(int i) {
		return exceptions[i];
	}

	@Override
	public MemberCategory getCategory() {
		return MemberCategory.METHOD;
	}

	public boolean isConstructor() {
		return getName().equals("this");/*return getSource().getNodeType() == NodeType.CONSTRUCTOR_DECLARATION;*/
	}
	
	public ParameterSet getParameters() {
		return parameters;
	}
	
	/**
	 * If this is an instance constructor, checks if it's body begins with a call to another/super constructor and
	 * marks that constructor's location as approved.
	 * @return true if this is an instance constructor starting with an explicit (and now marked "approved")
	 * call to another/super constructor, otherwise false.
	 */
	public boolean checkExplicitBaseConstructorCall(boolean includingThisConstructorCall) {
		if (isConstructor() && hasBody()) {
			if (getBody() instanceof BlockStatement) {
				BlockStatement b = (BlockStatement) getBody();
				if (b.countInnerStatements() > 0) {
					StatementModel first = b.getInnerStatement(0);
					if (first instanceof ExpressionStatement) {
						ExpressionModel expr = ((ExpressionStatement)first).getExpression();
						if (expr instanceof ThisConstructorCallExpression) {
							((ThisConstructorCallExpression)expr).setApprovedLocation(true);
							if (includingThisConstructorCall) {
								return true;
							}
						} else if (expr instanceof SuperConstructorCallExpression) {
							((SuperConstructorCallExpression)expr).setApprovedLocation(true);
							return true;
						}
					}
				}
			}
		}
		
		return false;
	}
	
	public boolean isStaticInitialisation() {
		return getSource() != null && getSource().getNodeType() == NodeType.STATIC_CONSTRUCTOR_DECLARATION;
	}
	
	public boolean hasBody() {
		if (body != null) {
			return true;
		} else if (isSynthetic()) {
			return body != null;
		} else {
			return getSource().getSubnode(getSource().countSubnodes() - 1).getNodeType() == NodeType.METHOD_BODY;
		}
	}
	
	public BlockStatement getBody() {
		return body;
	}
	
	public boolean hasReturnType() {
		return returnType != null;
	}
	
	public TypeModel getReturnType() {
		return returnType;
	}
	
	@Override
	public void dump(Reporter reporter, String indent, String incr) {
		// TODO Auto-generated method stub
		super.dump(reporter, indent, incr);

		if (hasReturnType()) {
			reporter.note("DUMP", indent + incr + "> Return type is " + getReturnType());
		} else {
			reporter.note("DUMP", indent + incr + "[no/void return type]");
		}
		
		if (parameters.countParameters() == 0) {
			reporter.note("DUMP", indent + incr + "[no parameters]");
		} else {
			reporter.note("DUMP", indent + incr + "> " + parameters.countParameters() + " parameters:");
		}
		
		for (int i = 0; i < parameters.countParameters(); i++) {
			parameters.getParameter(i).dump(reporter, indent + incr + incr, incr);
		}
		
		if (hasBody()) {
			reporter.note("DUMP", indent + incr + "> Method body: ...");
			//body.dump(reporter, indent + incr + incr, incr);
		} else {
			reporter.note("DUMP", indent + incr + "[no method body]");
		}
	}
	
	@Override
	public boolean isStatic() {
		return super.isStatic() /*|| isConstructor()*/ || isStaticInitialisation();
	}
	
	//@Override
	public TypeModel resolveType(Node typeReference) {
		return ((UserTypeModel)getOwner()).resolveTypeReference(typeReference);
	}
	//@Override
	public MethodModel getMethodOrField() {
		return this;
	}

	//@Override
	public InnerTypeScope getTypeScope() {
		return getOwner();
	}
	
	//@Override
	public Named lookupSimpleName(String name) {
		if (parameters != null && parameters.hasParameter(name)) {
			return parameters.getParameter(name);
		}
		return getOwner().lookupSimpleName(name);
	}
	
	public MethodModel[] lookupSimpleMethod(String name) {
		return getOwner().lookupSimpleMethod(name);
	}
	
	public String signatureString() {
		String result = getName();
		result += "(";
		
		if (parameters != null) {
			for (int i = 0; i < parameters.countParameters(); i++) {
				if (i != 0) {
					result += ",";
				}
				ParameterModel m = parameters.getParameter(i);
				result += m.getStorageType().fullName();
			}
		}
		
		result += ")";
		
		if (returnType != null) {
			result += ":" + returnType.fullName();
		}
		
		return result;
	}
	
	@Override
	public String toString() {
		return getOwner().toString() + "." + signatureString();
	}
	
	public boolean overrides(MethodModel other) {
		//System.err.println("Checking if " + this + " overrides " + other + "...");
		// Perform obvious checks first - if names don't match we don't override
		if (!getName().equals(other.getName())) {
			//System.err.println("Doesn't override - names don't match");
			return false;
		}
		// If other type isn't an ancestor of this type we don't override
		if (!getOwner().inherits(other.getOwner())) {
			//System.err.println("Doesn't override - doesn't fit hierarchy");
			return false;
		}
		// In the special case of constructors, they will be considered to logically override any inherited constructors
		if (isConstructor()) {
			//System.err.println("Does kind-of override - is constructor");
			return true;
		}
		// If names/types can lead to a potential override, we need to check parameters/return types
		if (!canOverrideParameters(other.parameters)) {
			//System.err.println("Doesn't override - parameters don't match");
			return false;
		}
		if (!canOverrideReturn(other.returnType)) {
			//System.err.println("Doesn't override - return types are incompatible");
			return false;
		}
		
		//System.err.println("Signatures match so it does override");
		return true;
	}
	
	public boolean canOverrideParameters(ParameterSet other) {
		if (parameters.countParameters() != other.countParameters()) {
			//System.err.println("Patemeter counts don't match");
			return false;
		}
		for (int i = 0; i < parameters.countParameters(); i++) {
			ParameterModel thisp = parameters.getParameter(i);
			ParameterModel otherp = other.getParameter(i);
			if (thisp.getStorageType() != otherp.getStorageType()) {
				//System.err.println("Storage types " + thisp.getStorageType() + " and " + otherp.getStorageType() + " don't match");
				return false;
				/*if (!(thisp.getStorageType() instanceof UserTypeModel) || !(otherp.getStorageType() instanceof UserTypeModel)) {
					return false;
				}*/
				/*if (!thisp.getStorageType().isAssignableFrom(otherp.getStorageType())) {
					return false;
				}*/
				
			}
		}
		// If nothing mismatched we can override
		return true;
	}
	
	public boolean canOverrideReturn(TypeModel otherReturnType) {
		if (returnType == otherReturnType) {
			return true;
		} else if (returnType != null && otherReturnType != null) {
			return otherReturnType.isAssignableFrom(returnType);
		} else {
			return false;
		}
	}

	@Override
	public int resolveExpressions() {
		if (hasBody()) {
			return getBody().resolveExpressions();
		} else {
			return 0;
		}
	}
	
	public boolean isApplicableToArguments(Arguments arguments, boolean allowVarargs) {
		ExpressionModel[] exprs = arguments.getSubexpressions();
		if ((!allowVarargs || !parameters.isVarargs()) && exprs.length != parameters.countParameters()) {
			return false;
		} else if (allowVarargs && parameters.isVarargs() && exprs.length < parameters.countNonVarargParameters()) {
			return false;
		}
		for (int i = 0; i < exprs.length; i++) {
			ExpressionResult r = exprs[i].getResult();
			if (r.resolvesToValueOrNull()) {
				if (r.getKind() == ExpressionResult.Kind.NULL) {
					if (!parameters.getParameterType(i, allowVarargs).isObjectType()) {
						return false;
					}
				} else {
					if (!parameters.getParameterType(i, allowVarargs).isAssignableFrom(r.getValueType())) {
						return false;
					}
				}
			} else {
				return false;
			}
		}
		
		/* If nothing was a mismatch, it should be good to go! */
		return true;
	}
	
	public boolean isLeftAssignableFromRight(ParameterSet left, ParameterSet right, boolean allowVarargs) {
		if (left.countParameters() != right.countParameters()) {
			return false;
		}
		for (int i = 0; i < left.countParameters(); i++) {
			if (!left.getParameterType(i, allowVarargs).isAssignableFrom(right.getParameterType(i, allowVarargs))) {
				return false;
			}
		}
		return true;
	}
	
	public int compareApplicabilityOfArguments(MethodModel other, Arguments arguments, boolean allowVarargs) {
		if (isLeftAssignableFromRight(this.parameters, other.parameters, allowVarargs)) {
			return -1;
		} else if (isLeftAssignableFromRight(other.parameters, this.parameters, allowVarargs)) {
			return 1;
		} else {
			return 0;
		}
	}
	
	public static int compareApplicabilityOfArguments(MethodModel[] lhs, MethodModel[] rhs, Arguments arguments, boolean allowVarargs) {
		if (lhs.length == 0 && rhs.length > 0) {
			return 1;
		} else if (rhs.length == 0 && lhs.length > 0) {
			return -1;
		}
		for (int i = 0; i < lhs.length; i++) {
			for (int j = 0; i < rhs.length; j++) {
				int comp = lhs[i].compareApplicabilityOfArguments(rhs[j], arguments, allowVarargs);
				if (comp != 0) {
					return comp;
				}
			}
		}
		return 0;
	}
	
	public static MethodModel[] addArrays(MethodModel[] a, MethodModel[] b) {
		MethodModel[] c = new MethodModel[a.length + b.length];
		for (int i = 0; i < c.length; i++) {
			c[i] = i < a.length ? a[i] : b[i - a.length];
		}
		return c;
	}
	
	public static MethodModel[] arrayWithout(MethodModel[] a, MethodModel b) {
		MethodModel[] c = new MethodModel[0];
		for (int i = 0; i < a.length; i++) {
			if (a[i] != b) {
				c = addArrays(c, new MethodModel[] {a[i]});
			}
		}
		return c;
	}
	
	public static boolean arrayContains(MethodModel[] a, MethodModel b) {
		for (int i = 0; i < a.length; i++) {
			if (a[i] == b) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Returns a new array of MethodModel instances where any duplicate entries or those
	 * made irrelevant by others in the list which override them are removed.
	 * 
	 * <p/>
	 * This shouldn't normally be used directly, but is used internally by findApplicableMethods/bestApplicableMethod.
	 * @param availableMethods
	 * @return
	 */
	public static MethodModel[] findRelevantMethods(MethodModel[] availableMethods, boolean checkOverrides) {
		MethodModel[] result = new MethodModel[0];
		
		for (int i = 0; i < availableMethods.length; i++) {
			MethodModel thisMethod = availableMethods[i];
			boolean willAdd = true;
			for (int j = 0; j < availableMethods.length; j++) {
				if (checkOverrides && i != j) {
					MethodModel otherMethod = availableMethods[j];
					if (otherMethod.overrides(thisMethod)) {
						//System.err.println("Method " + thisMethod + " is overridden by " + otherMethod + " so will be ignored");
						willAdd = false;
					}
				}
			}
			// Avoid adding any already-existing results so this method can also remove duplicates
			if (willAdd && !arrayContains(result, availableMethods[i])) {
				//System.err.println("Method " + thisMethod + " will be considered");
				result = addArrays(result, new MethodModel[] {availableMethods[i]});
			}
		}
		
		return result;
	}
	
	/**
	 * Narrows down a list of available methods/constructors (i.e. which have been looked up by name) to
	 * those which are applicable to the given arguments. This also avoids adding any methods which are
	 * overridden by a method already on the list.
	 * 
	 * <p/>
	 * This shouldn't normally be used directly, instead bestApplicableMethods should be used to get a
	 * reduced list.
	 * 
	 * @param availableMethods
	 * @param arguments
	 * @return
	 */
	public static MethodModel[] findApplicableMethods(MethodModel[] availableMethods, Arguments arguments, boolean allowVarargs) {
		// Begin by removing any duplicate methods
		// (note, overridden methods should already be excluded UNLESS they also occur in scope
		// actually, that probably never happens anyway. Doesn't seem to be an issue?)
		availableMethods = findRelevantMethods(availableMethods, false);
		
		MethodModel[] result = new MethodModel[0];
		
		for (int i = 0; i < availableMethods.length; i++) {
			//System.err.println("Checking if " + availableMethods[i] + " matches " + arguments);
			if (availableMethods[i].isApplicableToArguments(arguments, allowVarargs)) {
				//System.err.println("Match.");
				result = addArrays(result, new MethodModel[] {availableMethods[i]});
				//System.err.println("Result length: " + result.length);
			} else {
				//System.err.println("No match.");
			}
		}
		
		return result;
	}
	
	/**
	 * Returns an array of the "most applicable" methods (based on the arguments) from an array of
	 * available choices.
	 * 
	 * <p/>
	 * This method first calls findApplicableMethods to limit to those which are applicable.
	 * If no methods are applicable, an empty array is returned. If more than one are applicable, then
	 * this method will try to select the "most applicable" from those, ideally returning exactly
	 * one method but including any ambiguous ones if necessary.
	 * 
	 * @param availableMethods
	 * @param arguments
	 * @return
	 */
	public static MethodModel[] bestApplicableMethods(MethodModel[] availableMethods, Arguments arguments, boolean allowVarargs) {
		MethodModel[] applicable = findApplicableMethods(availableMethods, arguments, allowVarargs);
		/* If there's only one applicable method (or none) then we don't have to do any more work to
		 * choose between them.
		 */
		if (applicable.length < 2) {
			return applicable;
		}
		
		MethodModel[] mostApplicable = new MethodModel[0];
		
		for (int i = 0; i < applicable.length; i++) {
			if (mostApplicable.length == 0) {
				mostApplicable = new MethodModel[] {applicable[i]};
			} else {
				MethodModel[] newMostApplicable = new MethodModel[0];
				for (int j = 0; j < mostApplicable.length; j++) {
					int comp = applicable[i].compareApplicabilityOfArguments(mostApplicable[j], arguments, allowVarargs);
					if (comp < 0) {
						newMostApplicable = addArrays(newMostApplicable, new MethodModel[] {mostApplicable[j]});
					} else if (comp > 0) {
						newMostApplicable = addArrays(newMostApplicable, new MethodModel[] {applicable[i]});
					} else {
						newMostApplicable = addArrays(newMostApplicable, new MethodModel[] {mostApplicable[j], applicable[i]});
					}
				}
				mostApplicable = newMostApplicable;
			}
			/*
			MethodModel[] newArray = new MethodModel[] {applicable[i]};
			int slangc = compareApplicabilityOfArguments(mostApplicable, newArray, arguments);
			if (slangc < 0) {
				mostApplicable = newArray;
			} else if (slangc > 0) {
				// the existing ones are more applicable, no further action is required
			} else {
				// they are equally applicable, so we add the two lists together
				mostApplicable = addArrays(mostApplicable, newArray);
			}
			*/
		}
		
		return mostApplicable;
	}

	public MethodSignature getMethodSignature() {
		TypeSignature[] argsigs = new TypeSignature[parameters.countParameters()];
		for (int i = 0; i < argsigs.length; i++) {
			argsigs[i] = parameters.getParameter(i).getStorageType().getTypeSignature();
		}
		MethodSignature.Kind kind;
		if (isStaticInitialisation()) {
			kind = MethodSignature.Kind.STATIC_INIT;
		} else if (isConstructor()) {
			kind = MethodSignature.Kind.CONSTRUCTOR;
		} else if (getOwner().getTypeType() == TypeType.INTERFACE || getOwner().getTypeType() == TypeType.INTERFACE_TEMPLATE) {
			kind = isStatic() ? MethodSignature.Kind.STATIC_METHOD : MethodSignature.Kind.INTERFACE_METHOD;
		} else {
			kind = isStatic() ? MethodSignature.Kind.STATIC_METHOD : MethodSignature.Kind.INSTANCE_METHOD;
		}
		return new MethodSignature(getOwner().getTypeSignature(), kind, returnType == null ? TypeSignature.VOID : returnType.getTypeSignature(), getName(), argsigs);
	}

	public int countParameters() {
		return parameters.countParameters();
	}
	
	public ParameterModel getParameter(int indexFromLeft) {
		return parameters.getParameter(indexFromLeft);
	}
	
	private List<LocalStorageModel> getLocals() {
		if (locals == null) {
			locals = new List<LocalStorageModel>();
			for (int i = 0; i < countParameters(); i++) {
				locals.append(parameters.getParameter(i));
			}
		}
		return locals;
	}

	public int countLocals() {
		return getLocals().count();
	}
	
	void localAdded(LocalVariableSlot l) {
		getLocals().append(l);
	}
	
	@Override
	public int getFlags() {
		int f = super.getFlags();
		
		if (isConstructor() || isStaticInitialisation()) {
			f |= Flags.MASK_CONSTRUCTOR;
		}
		
		if (isSynthetic()) {
			f |= Flags.MASK_SYNTHETIC;
		}
		
		return f;
	}
	
	public MethodModel getPrototype() {
		return prototype;
	}
}