private bool IsCurrentMethodDynamic(MethodType originalMethodType)
{
for (int i = 0; i < originalMethodType.ParameterListCount; i++)
{
if (originalMethodType.GetParameter(i).IsDynamic)
{
return(true);
}
}
return(false);
}
public override Object Visit(InvocationExpression node, Object obj)
{
MethodType originalMemberTypeExpression = node.ActualMethodCalled as MethodType;
if (node.Arguments.ExpressionCount == 0 || originalMemberTypeExpression == null || !originalMemberTypeExpression.HasTypeVariables())
{
return(null);
}
TypeExpression[] args = this.compoundExpressionToArray(node.Arguments); //VisitorInference pass when error??
if (args == null)
{
return(null);
}
MethodDefinition originalMethodDefinition = originalMemberTypeExpression.ASTNode as MethodDefinition;
if (originalMethodDefinition == null)
{
return(null);
}
TypeExpression[] originalParamsType = new TypeExpression[originalMemberTypeExpression.ParameterListCount];
for (int i = 0; i < originalMemberTypeExpression.ParameterListCount; i++)
{
originalParamsType[i] = originalMemberTypeExpression.GetParameter(i);
}
var originalMethodIndentificator = MethodIndentificator(originalMethodDefinition.FullName, originalParamsType, true);
var methodIndentificator = MethodIndentificator(originalMethodDefinition.FullName, args);
if (methodIndentificator.Equals(originalMethodIndentificator)) //Method does not need to be specialized
{
if (!specilizedMethods.ContainsKey(originalMethodIndentificator))
{
specilizedMethods[originalMethodIndentificator] = originalMethodDefinition;
}
return(null);
}
bool specializeOrCreate = !HasUnionTypes(originalMethodDefinition.FullName, methodIndentificator);
MethodDefinition method = specializeOrCreate ? SpecilizeMethod(methodIndentificator, originalMethodDefinition, args) : CreateMethod(methodIndentificator, originalMethodIndentificator, originalMethodDefinition, args, node);
if (method != null)
{
UpdateActualMethodCalled(node, method, specializeOrCreate);
method.Accept(this, obj);
}
else if (pendingMethods.ContainsKey(methodIndentificator))
{
pendingMethods[methodIndentificator].Add(node);
}
return(null);
}
public override Object Visit(NewExpression node, Object obj)
{
MethodType originalMemberTypeExpression = node.ActualMethodCalled as MethodType;
if (node.Arguments.ExpressionCount == 0 || originalMemberTypeExpression == null || !originalMemberTypeExpression.HasTypeVariables())
{
return(null);
}
TypeExpression[] args = this.compoundExpressionToArray(node.Arguments); //VisitorInference pass when error??
if (args == null)
{
return(null);
}
MethodDefinition originalMethodDefinition = originalMemberTypeExpression.ASTNode as MethodDefinition;
if (originalMethodDefinition == null)
{
return(null);
}
TypeExpression[] originalParamsType = new TypeExpression[originalMemberTypeExpression.ParameterListCount];
for (int i = 0; i < originalMemberTypeExpression.ParameterListCount; i++)
{
originalParamsType[i] = originalMemberTypeExpression.GetParameter(i);
}
var originalMethodIndentificator = MethodIndentificator(originalMethodDefinition.FullName, originalParamsType, true);
var methodIndentificator = MethodIndentificator(originalMethodDefinition.FullName, args);
if (methodIndentificator.Equals(originalMethodIndentificator)) //Method does not need to be specialized
{
if (!specilizedMethods.ContainsKey(originalMethodIndentificator))
{
specilizedMethods[originalMethodIndentificator] = originalMethodDefinition;
}
return(null);
}
if (HasUnionTypes(originalMethodDefinition.FullName, methodIndentificator))
{
return(null); //Any parameter is a UnionType, It is imposible to specilize constructor.
}
MethodDefinition method = SpecilizeMethod(methodIndentificator, originalMethodDefinition, args);
if (method != null)
{
UpdateActualMethodCalled(node, method, true);
}
return(null);
}
internal override void RuntimeCheckArguments(InvocationExpression node, Object objArgs, MethodType actualMethodCalled, List <string> nextMethod)
{
for (int j = 0; j < node.Arguments.ExpressionCount; j++)
{
node.Arguments.GetExpressionElement(j).Accept(this, objArgs);
actualMethodCalled.GetParameter(j).AcceptOperation(new CGRuntimeCheckArgumentOperation <T>(this.indent, this.codeGenerator, nextMethod), null);
//if ((!(actualMethodCalled.GetParameter(j).IsValueType()))
// || (actualMethodCalled.GetParameter(j) is BoolType) || (actualMethodCalled.GetParameter(j) is CharType))
//{
// this.codeGenerator.dup(this.indent);
// this.codeGenerator.isinst(this.indent, actualMethodCalled.GetParameter(j));
// // if check fail then check nextMethod
// nextMethod.Add(this.codeGenerator.NewLabel);
// this.codeGenerator.brfalse(this.indent, nextMethod[nextMethod.Count - 1]);
// if (actualMethodCalled.GetParameter(j).IsValueType())
// this.codeGenerator.UnboxAny(this.indent, actualMethodCalled.GetParameter(j));
//}
//else
//{
// // Param is Int. Is the argument an int?
// if (actualMethodCalled.GetParameter(j) is IntType)
// {
// string nextArgument = this.codeGenerator.NewLabel;
// CharType.Instance.AcceptOperation(new CGRuntimeCheckTypeExpressionOperation(this.indent, this.codeGenerator, nextArgument, false));
// IntType.Instance.AcceptOperation(new CGRuntimeCheckTypeExpressionOperation(this.indent, this.codeGenerator, nextArgument, false));
// nextMethod.Add(this.codeGenerator.NewLabel);
// this.codeGenerator.br(this.indent, nextMethod[nextMethod.Count - 1]);
// this.codeGenerator.WriteLabel(nextArgument);
// }
// else
// {
// // Param is Double. Is the argument a double?
// if (actualMethodCalled.GetParameter(j) is DoubleType)
// {
// string nextArgument = this.codeGenerator.NewLabel;
// CharType.Instance.AcceptOperation(new CGRuntimeCheckTypeExpressionOperation(this.indent, this.codeGenerator, nextArgument, true));
// IntType.Instance.AcceptOperation(new CGRuntimeCheckTypeExpressionOperation(this.indent, this.codeGenerator, nextArgument, true));
// DoubleType.Instance.AcceptOperation(new CGRuntimeCheckTypeExpressionOperation(this.indent, this.codeGenerator, nextArgument, true));
// nextMethod.Add(this.codeGenerator.NewLabel);
// this.codeGenerator.br(this.indent, nextMethod[nextMethod.Count - 1]);
// this.codeGenerator.WriteLabel(nextArgument);
// }
// }
//}
}
}
public override object Exec(MethodType operand1, object arg)
{
if (operand1 == this.operand2)
{
return(true);
}
TypeVariable typeVariable = this.operand2 as TypeVariable;
if (typeVariable != null)
{
return(typeVariable.AcceptOperation(new EquivalentOperation(operand1), arg));
}
MethodType method = this.operand2 as MethodType;
// * It must be a method
if (method == null)
{
return(false);
}
// * Same name
if (!operand1.MemberInfo.MemberIdentifier.Equals(method.MemberInfo.MemberIdentifier))
{
return(false);
}
// * Same class
if (!(bool)operand1.MemberInfo.Class.AcceptOperation(new EquivalentOperation(method.MemberInfo.Class), null))
{
return(false);
}
// * Same signature
if (operand1.ParameterListCount != method.ParameterListCount)
{
return(false);
}
for (int i = 0; i < operand1.ParameterListCount; i++)
{
if (!(bool)operand1.GetParameter(i).AcceptOperation(new EquivalentOperation(method.GetParameter(i)), null))
{
return(false);
}
}
return(true);
}
public override object Exec(MethodType m, object arg)
{
MethodType method = this.typeExpression as MethodType;
if (method == null)
{
return(false);
}
if (m.ParameterListCount != method.ParameterListCount)
{
return(false);
}
for (int i = 0; i < method.ParameterListCount; i++)
{
if (!(bool)m.GetParameter(i).AcceptOperation(new EqualsForOverloadOperation(method.GetParameter(i)), arg))
{
return(false);
}
}
return(true);
}
private StaDynSignature CreateSignature(ITextBuffer textBuffer, MethodType method, string methodDoc, ITrackingSpan span)
{
string name = method.MemberInfo.MemberIdentifier;
string returnType = method.Return.FullName;
string description = returnType + " " + name;
string methodSig = description;
StaDynSignature sig = new StaDynSignature(textBuffer, methodSig, methodDoc, null);
textBuffer.Changed += new EventHandler <TextContentChangedEventArgs>(sig.OnSubjectBufferChanged);
List <IParameter> paramList = new List <IParameter>();
//Generate a correct signature
methodSig += " ( ";
int locusSearchStart = 0;
if (method.ASTNode != null)
{
//ParametersInfo available (There is access to the definition of the method)
foreach (Parameter param in method.ASTNode.ParametersInfo)
{
string pName = param.Identifier;
string pDescription = param.ParamType + " " + pName;
methodSig += " " + pDescription + " ,";
int locusStart = methodSig.IndexOf(pDescription, locusSearchStart);
if (locusStart >= 0)
{
Span locus = new Span(locusStart, pDescription.Length);
locusSearchStart = locusStart + pDescription.Length;
paramList.Add(new StaDynParameter(pDescription, locus, pDescription, sig));
}
}
}
else
{
//ParametersInfo not available (There is not access to the definition of the method)
for (int i = 0; i < method.ParameterListCount; i++)
{
string pDescription = method.GetParameter(i).FullName;
methodSig += " " + pDescription + " ,";
int locusStart = methodSig.IndexOf(pDescription, locusSearchStart);
if (locusStart >= 0)
{
Span locus = new Span(locusStart, pDescription.Length);
locusSearchStart = locusStart + pDescription.Length;
paramList.Add(new StaDynParameter(pDescription, locus, pDescription, sig));
}
}
}
//Complete the method signature
int lastComma = methodSig.LastIndexOf(',');
if (lastComma >= 0)
{
methodSig = methodSig.Remove(lastComma);
}
methodSig += ")";
//Update signature
sig.Content = methodSig;
sig.Parameters = new ReadOnlyCollection <IParameter>(paramList);
sig.ApplicableToSpan = span;
sig.ComputeCurrentParameter();
return(sig);
}
private MethodDefinition CreateMethod(string fullMethodIndentificator, string originalMethodIndentificator, MethodDefinition originalMethodDefinition, TypeExpression[] args, BaseCallExpression node)
{
if (!specilizedMethods.ContainsKey(fullMethodIndentificator))
{
String methodIndentificator = fullMethodIndentificator.Replace(originalMethodDefinition.FullName, originalMethodDefinition.Identifier);
List <MethodDefinition> methods = new List <MethodDefinition>();
foreach (TypeExpression[] listOfArgs in GetTypes(args))
{
String currentMethodIdentificator = MethodIndentificator(originalMethodDefinition.FullName, listOfArgs);
MethodDefinition md;
if (currentMethodIdentificator.Equals(originalMethodIndentificator))
{
md = originalMethodDefinition;
}
else
{
md = SpecilizeMethod(currentMethodIdentificator, originalMethodDefinition, listOfArgs);
}
if (md != null && !methods.Any(m => m.ILTypeExpression.Equals(md.ILTypeExpression)))
{
methods.Add(md);
}
}
MethodType originalMethodType = (MethodType)originalMethodDefinition.TypeExpr;
isCurrentMethodDynamic = IsCurrentMethodDynamic(originalMethodType);
MethodType newMethodType = new MethodType(originalMethodType.Return);
Location location = originalMethodDefinition.IdentifierExp.Location;
SingleIdentifierExpression newSingleIdentifierExpression = new SingleIdentifierExpression(methodIndentificator, location);
Block newBlock = new Block(location);
IList <InvocationExpression> invocations = new List <InvocationExpression>();
IList <CastExpression> castExpressions = new List <CastExpression>();
int methodsCount = 0;
foreach (var methodDefinition in methods)
{
MethodType methodType = (MethodType)methodDefinition.TypeExpr;
IList <IsExpression> isExpressions = new List <IsExpression>();
CompoundExpression compoundExpression = new CompoundExpression(location);
for (int i = 0; i < methodDefinition.ParametersInfo.Count; i++)
{
SingleIdentifierExpression identifier = new SingleIdentifierExpression(methodDefinition.ParametersInfo[i].Identifier, location);
identifier.IndexOfSSA = 0;
if (args[i] is UnionType || (args[i] is TypeVariable && ((TypeVariable)args[i]).Substitution is UnionType))
{
IsExpression isExpression = new IsExpression(identifier,
methodType.GetParameter(i).Freeze().ILType(), location);
isExpression.TypeExpr = methodType.GetParameter(i).Freeze();
isExpressions.Add(isExpression);
CastExpression castExpression = new CastExpression(isExpression.TypeExpr.ILType(),
identifier, location);
castExpressions.Add(castExpression);
castExpression.CastType = isExpression.TypeExpr;
compoundExpression.AddExpression(castExpression);
}
else
{
compoundExpression.AddExpression(identifier);
}
}
Expression condition = isExpressions[0];
if (isExpressions.Count > 1)
{
for (int i = 1; i < isExpressions.Count; i++)
{
condition = new LogicalExpression(condition, isExpressions[i], LogicalOperator.And, location);
}
}
InvocationExpression invocationExpression = new InvocationExpression(methodDefinition.IdentifierExp, compoundExpression, location);
invocations.Add(invocationExpression);
ReturnStatement returnStatement = new ReturnStatement(invocationExpression, location);
if (++methodsCount < methods.Count || isCurrentMethodDynamic)
{
IfElseStatement ifElseStatement = new IfElseStatement(condition, returnStatement, location);
newBlock.AddStatement(ifElseStatement);
}
else if (!isCurrentMethodDynamic)
{
newBlock.AddStatement(returnStatement);
}
}
//If there is any dynamic union type then it is necessary invoke the original method
if (isCurrentMethodDynamic)
{
CompoundExpression compoundExpression = new CompoundExpression(location);
foreach (var parameter in originalMethodDefinition.ParametersInfo)
{
SingleIdentifierExpression identifier = new SingleIdentifierExpression(parameter.Identifier, location);
identifier.IndexOfSSA = 0;
compoundExpression.AddExpression(identifier);
}
newBlock.AddStatement(new ReturnStatement(new InvocationExpression(new SingleIdentifierExpression(originalMethodDefinition.Identifier, location), compoundExpression, location), location));
}
MethodDefinition newMethodDefinition = new MethodDefinition(newSingleIdentifierExpression, newBlock,
originalMethodDefinition.ReturnTypeInfo, originalMethodDefinition.ParametersInfo,
originalMethodDefinition.ModifiersInfo, location);
newMethodDefinition.FullName = fullMethodIndentificator;
newMethodType.MemberInfo = new AccessModifier(originalMethodType.MemberInfo.Modifiers, newSingleIdentifierExpression.Identifier, newMethodType, false);
newMethodType.MemberInfo.Class = originalMethodType.MemberInfo.Class;
newMethodType.MemberInfo.TypeDefinition = originalMethodType.MemberInfo.TypeDefinition;
for (int i = 0; i < originalMethodType.ParameterListCount; i++)
{
newMethodType.AddParameter(args[i].Simplify());
}
newMethodType.ASTNode = newMethodDefinition;
newMethodDefinition.TypeExpr = newMethodType;
newMethodDefinition.TypeExpr.BuildFullName();
newMethodDefinition.TypeExpr.BuildTypeExpressionString(4);
TypeDefinition originalTypeDefinition = newMethodType.MemberInfo.TypeDefinition;
originalTypeDefinition.AddMethod(newMethodDefinition);
UserType originalClass = newMethodType.MemberInfo.Class;
originalClass.AddMember(methodIndentificator, newMethodType.MemberInfo);
newMethodDefinition.Accept(new VisitorSymbolIdentification(null), null);
bool previousDynamism = DynVarOptions.Instance.EverythingDynamic;
DynVarOptions.Instance.EverythingDynamic = false;
newMethodDefinition.Accept(visitorTypeInference, null);
DynVarOptions.Instance.EverythingDynamic = previousDynamism;
foreach (var invocation in invocations)
{
if (invocation.ActualMethodCalled is UnionType)
{
invocation.ActualMethodCalled = ((UnionType)invocation.ActualMethodCalled).TypeSet[1];
}
}
foreach (var castExpression in castExpressions)
{
((SingleIdentifierExpression)castExpression.Expression).FrozenTypeExpression = new ClassType("System.Object");
castExpression.Expression.ExpressionType = new ClassType("System.Object");
}
specilizedMethods.Add(fullMethodIndentificator, newMethodDefinition);
return(newMethodDefinition);
}
return(specilizedMethods[fullMethodIndentificator]);
}
public override Object Visit(MethodDefinition node, Object obj)
{
typeVariableMappings = new Dictionary <TypeVariable, TypeVariable>();
typeExpresionVariableMapping = new Dictionary <TypeExpression, TypeExpression>();
var previouslyUnified = new List <Pair <TypeExpression, TypeExpression> >();
MethodType originalMethodType = (MethodType)node.TypeExpr;
TypeExpression[] args = (TypeExpression[])obj;
TypeExpression[] clonedArgs = new TypeExpression[args.Count()];
List <Parameter> clonedParametersInfo = new List <Parameter>();
for (int i = 0; i < node.ParametersInfo.Count; i++)
{
Parameter originalParameter = node.ParametersInfo[i];
TypeExpression originalParamType = originalMethodType.GetParameter(i);
if (originalParamType is TypeVariable)
{
TypeVariable clonedParamType = (TypeVariable)originalParamType.CloneType(typeVariableMappings);
if (clonedParamType.EquivalenceClass != null)
{
clonedParamType.EquivalenceClass.add(args[i], SortOfUnification.Override, previouslyUnified);
typeExpresionVariableMapping.Add(originalParamType, clonedParamType);
originalParamType = clonedParamType;
}
else
{
typeExpresionVariableMapping.Add(originalParamType, args[i]);
originalParamType = args[i];
}
}
originalParamType.ValidTypeExpression = false;
clonedArgs[i] = originalParamType.Simplify();
var parameter = new Parameter()
{
Identifier = originalParameter.Identifier, Column = originalParameter.Column, Line = originalParameter.Line, ParamType = clonedArgs[i].typeExpression
};
if (parameter.ParamType == null || !originalParameter.ILName.Equals(parameter.ILName))
{
var rebuildParamType = clonedArgs[i].ToString();
parameter.ParamType = clonedArgs[i].typeExpression;
}
clonedParametersInfo.Add(parameter);
}
foreach (var constraint in originalMethodType.Constraints.Constraints)
{
if (constraint is CloneConstraint)
{
CloneConstraint cc = constraint as CloneConstraint;
if (typeExpresionVariableMapping.ContainsKey(cc.FirstOperand))
{
typeExpresionVariableMapping.Add(cc.ReturnType, typeExpresionVariableMapping[cc.FirstOperand]);
}
}
}
MethodType clonedMethodType = new MethodType(originalMethodType.Return.CloneType(typeVariableMappings, typeExpresionVariableMapping));
currentMethodType = clonedMethodType;
SingleIdentifierExpression clonedSingleIdentifierExpression = new SingleIdentifierExpression(node.IdentifierExp.Identifier, node.IdentifierExp.Location);
Block clonedBlock = (Block)node.Body.Accept(this, null);
MethodDefinition clonedMethodDefinition = null;
if (node is ConstructorDefinition)
{
clonedMethodDefinition = new ConstructorDefinition(clonedSingleIdentifierExpression, node.ModifiersInfo, clonedParametersInfo, null, clonedBlock, node.Location);
}
else
{
clonedMethodDefinition = new MethodDefinition(clonedSingleIdentifierExpression, clonedBlock, clonedMethodType.Return.typeExpression, clonedParametersInfo, node.ModifiersInfo, node.Location);
}
clonedMethodDefinition.FullName = node.FullName;
clonedMethodType.MemberInfo = new AccessModifier(originalMethodType.MemberInfo.Modifiers, clonedSingleIdentifierExpression.Identifier, clonedMethodType, false);
clonedMethodType.MemberInfo.Class = originalMethodType.MemberInfo.Class;
clonedMethodType.MemberInfo.TypeDefinition = originalMethodType.MemberInfo.TypeDefinition;
for (int i = 0; i < originalMethodType.ParameterListCount; i++)
{
clonedMethodType.AddParameter(clonedArgs[i]);
}
clonedMethodType.ASTNode = clonedMethodDefinition;
clonedMethodDefinition.TypeExpr = clonedMethodType;
var previousShowMessages = ErrorManager.Instance.ShowMessages;
ErrorManager.Instance.UnNotifiedErrors = false;
ErrorManager.Instance.ShowMessages = false;
clonedMethodDefinition.Accept(this.visitorSpecializer.visitorTypeInference, null);
ErrorManager.Instance.ShowMessages = previousShowMessages;
if (ErrorManager.Instance.UnNotifiedErrors)
{
ErrorManager.Instance.UnNotifiedErrors = false;
return(null);
}
TypeDefinition originalTypeDefinition = clonedMethodType.MemberInfo.TypeDefinition;
originalTypeDefinition.AddMethod(clonedMethodDefinition);
UserType originalClass = clonedMethodType.MemberInfo.Class;
AccessModifier am = originalClass.Members[clonedMethodDefinition.Identifier];
IntersectionMemberType intersectionMemberType = am.Type as IntersectionMemberType;
if (intersectionMemberType != null)
{
intersectionMemberType.TypeSet.Add(clonedMethodType);
}
else
{
am = clonedMethodType.MemberInfo;
IntersectionMemberType intersection = new IntersectionMemberType();
intersection.TypeSet.Add(originalMethodType);
intersection.TypeSet.Add(clonedMethodType);
am.Type = intersection;
originalClass.Members[clonedMethodDefinition.Identifier] = am;
}
clonedMethodDefinition.IdentifierExp.ExpressionType = clonedMethodDefinition.TypeExpr;
return(clonedMethodDefinition);
}
