private OverloadsCollection(IEmitter emitter, MethodDeclaration methodDeclaration)
{
this.Emitter = emitter;
this.Name = methodDeclaration.Name;
this.JsName = this.Emitter.GetEntityName(methodDeclaration, false, true);
this.Inherit = !methodDeclaration.HasModifier(Modifiers.Static);
this.Static = methodDeclaration.HasModifier(Modifiers.Static);
this.Member = this.FindMember(methodDeclaration);
this.TypeDefinition = this.Member.DeclaringTypeDefinition;
this.Type = this.Member.DeclaringType;
this.InitMembers();
this.Emitter.OverloadsCacheNodes[new Tuple <AstNode, bool>(methodDeclaration, false)] = this;
}
private OverloadsCollection(IEmitter emitter, MethodDeclaration methodDeclaration)
{
this.Emitter = emitter;
this.Name = methodDeclaration.Name;
this.JsName = this.Emitter.GetEntityName(methodDeclaration, false, true);
this.Inherit = !methodDeclaration.HasModifier(Modifiers.Static);
this.Static = methodDeclaration.HasModifier(Modifiers.Static);
this.Member = this.FindMember(methodDeclaration);
this.TypeDefinition = this.Member.DeclaringTypeDefinition;
this.Type = this.Member.DeclaringType;
this.InitMembers();
//this.Emitter.OverloadsCache[methodDeclaration.GetHashCode().ToString()] = this;
}
private OverloadsCollection(IEmitter emitter, MethodDeclaration methodDeclaration)
{
this.Emitter = emitter;
this.Name = methodDeclaration.Name;
this.JsName = this.Emitter.GetEntityName(methodDeclaration);
this.Inherit = !methodDeclaration.HasModifier(Modifiers.Static);
this.Static = methodDeclaration.HasModifier(Modifiers.Static);
this.Member = this.FindMember(methodDeclaration);
this.TypeDefinition = this.Member.DeclaringTypeDefinition;
this.Type = this.Member.DeclaringType;
this.InitMembers();
this.Emitter.Cache.AddNode(methodDeclaration, false, this);
}
private OverloadsCollection(IEmitter emitter, MethodDeclaration methodDeclaration)
{
this.Emitter = emitter;
this.Name = methodDeclaration.Name;
this.JsName = this.Emitter.GetEntityName(methodDeclaration, false, true);
this.Inherit = !methodDeclaration.HasModifier(Modifiers.Static);
this.Static = methodDeclaration.HasModifier(Modifiers.Static);
this.Member = this.FindMember(methodDeclaration);
this.TypeDefinition = this.Member.DeclaringTypeDefinition;
this.Type = this.Member.DeclaringType;
this.InitMembers();
this.Emitter.OverloadsCache[methodDeclaration.GetHashCode().ToString()] = this;
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
// TODO: Invert if without else
// ex. if (cond) DoSomething () == if (!cond) return; DoSomething ()
// beware of loop contexts return should be continue then.
var context = ctx;
if (methodDeclaration.HasModifier(Modifiers.Static) ||
methodDeclaration.HasModifier(Modifiers.Virtual) ||
methodDeclaration.HasModifier(Modifiers.Override) ||
methodDeclaration.HasModifier(Modifiers.New) ||
methodDeclaration.Attributes.Any())
{
return;
}
// skip empty methods
if (!methodDeclaration.Body.Statements.Any())
{
return;
}
if (methodDeclaration.Body.Statements.Count == 1)
{
if (methodDeclaration.Body.Statements.First() is ThrowStatement)
{
return;
}
}
var resolved = context.Resolve(methodDeclaration) as MemberResolveResult;
if (resolved == null)
{
return;
}
var isImplementingInterface = resolved.Member.ImplementedInterfaceMembers.Any();
if (isImplementingInterface)
{
return;
}
AddIssue(methodDeclaration.NameToken.StartLocation, methodDeclaration.NameToken.EndLocation,
context.TranslateString(string.Format("Make '{0}' static", methodDeclaration.Name)),
script => ExecuteScriptToFixStaticMethodIssue(script, context, methodDeclaration));
}
static bool IsDisposeMethod(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.PrivateImplementationType.IsNull)
{
//Ignore explictly implemented methods
return(false);
}
if (methodDeclaration.Name != "Dispose")
{
return(false);
}
if (methodDeclaration.Parameters.Count != 0)
{
return(false);
}
if (methodDeclaration.HasModifier(Modifiers.Static))
{
return(false);
}
var primitiveType = methodDeclaration.ReturnType as PrimitiveType;
if (primitiveType == null || primitiveType.KnownTypeCode != KnownTypeCode.Void)
{
return(false);
}
return(true);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Partial))
{
return;
}
var resolveResult = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (resolveResult == null)
{
return;
}
var method = (IMethod)resolveResult.Member;
if (method == null)
{
return;
}
if (!method.HasBody)
{
return;
}
if (method.Parts.Count == 1)
{
AddIssue(new CodeIssue(methodDeclaration.NameToken,
string.Format(ctx.TranslateString("CS0759: A partial method `{0}' implementation is missing a partial method declaration"), method.FullName),
GetFixAction(methodDeclaration)));
}
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Abstract))
{
return;
}
base.VisitMethodDeclaration(methodDeclaration);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Static))
{
this.CheckDependency(methodDeclaration.ReturnType);
base.VisitMethodDeclaration(methodDeclaration);
}
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Static))
{
CheckDependency(methodDeclaration.ReturnType);
base.VisitMethodDeclaration(methodDeclaration);
}
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
base.VisitMethodDeclaration(methodDeclaration);
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
if (methodDeclaration.Body.Statements.Count != 1)
{
return;
}
var expr = methodDeclaration.Body.Statements.FirstOrNullObject();
//Debuger.WriteInFile(expr.FirstChild.ToString());
if (expr == null)
{
return;
}
if (expr.FirstChild is InvocationExpression)
{
var memberReferenceExpression = (expr.FirstChild as InvocationExpression).Target as MemberReferenceExpression;
if (memberReferenceExpression == null ||
memberReferenceExpression.MemberName != methodDeclaration.Name ||
!(memberReferenceExpression.FirstChild is BaseReferenceExpression))
{
return;
}
var title = ctx.TranslateString("Redundant method override");
AddIssue(methodDeclaration, title, ctx.TranslateString("Remove redundant method override"), script => {
script.Remove(methodDeclaration);
});
}
else if (expr.FirstChild is CSharpTokenNode && expr.FirstChild.ToString().Equals("return"))
{
var invocationExpression = expr.FirstChild.NextSibling as InvocationExpression;
if (invocationExpression == null)
{
return;
}
var memberReferenceExpression = invocationExpression.Target as MemberReferenceExpression;
if (memberReferenceExpression == null ||
memberReferenceExpression.MemberName != methodDeclaration.Name ||
!(memberReferenceExpression.FirstChild is BaseReferenceExpression))
{
return;
}
var title = ctx.TranslateString("Redundant method override");
AddIssue(methodDeclaration, title, ctx.TranslateString("Remove redundant method override"), script => {
script.Remove(methodDeclaration);
});
}
return;
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.Name != "GetHashCode" || !methodDeclaration.HasModifier(Modifiers.Override) || methodDeclaration.Parameters.Any())
{
return;
}
if (!ctx.Resolve(methodDeclaration.ReturnType).Type.IsKnownType(KnownTypeCode.Int32))
{
return;
}
base.VisitMethodDeclaration(methodDeclaration);
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (methodDeclaration.Name.ToLower().Equals("main") == false)
{
if (methodDeclaration.IsExtensionMethod == false &&
methodDeclaration.HasModifier(Modifiers.Abstract) == false)
{
UnlockWith(methodDeclaration);
}
}
return base.VisitMethodDeclaration(methodDeclaration, data);
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (methodDeclaration.Name.ToLower().Equals("main") == false)
{
if (methodDeclaration.IsExtensionMethod == false &&
methodDeclaration.HasModifier(Modifiers.Abstract) == false)
{
UnlockWith(methodDeclaration);
}
}
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Abstract) || this.HasInline(methodDeclaration))
{
return;
}
this.FixMethodParameters(methodDeclaration.Parameters, methodDeclaration.Body);
bool isStatic = methodDeclaration.HasModifier(Modifiers.Static);
Dictionary <string, List <MethodDeclaration> > dict = isStatic
? CurrentType.StaticMethods
: CurrentType.InstanceMethods;
var key = methodDeclaration.Name;
if (dict.ContainsKey(key))
{
dict[key].Add(methodDeclaration);
}
else
{
dict.Add(key, new List <MethodDeclaration>(new[] { methodDeclaration }));
}
var memberrr = Resolver.ResolveNode(methodDeclaration, null) as MemberResolveResult;
if (OverloadsCollection.NeedCreateAlias(memberrr))
{
var config = isStatic
? CurrentType.StaticConfig
: CurrentType.InstanceConfig;
config.Alias.Add(new TypeConfigItem {
Entity = methodDeclaration
});
}
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
bool forceWrite = false;
if (!methodDeclaration.HasModifier(Modifiers.Public) && methodDeclaration.Name == "Dispose")
{
forceWrite = true;
}
if (forceWrite)
{
base.VisitMethodDeclaration(methodDeclaration);
}
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Extern))
{
methodDeclaration.Remove();
return;
}
if (methodDeclaration.Name == ".dtor" || methodDeclaration.Name == "Finalize")
{
methodDeclaration.Remove();
return;
}
base.VisitMethodDeclaration(methodDeclaration);
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (!methodDeclaration.Name.ToLower().Equals("main"))
{
if (!methodDeclaration.IsExtensionMethod &&
!methodDeclaration.HasModifier(Modifiers.Abstract))
{
if (methodDeclaration.Body.Statements.Count() == 1 &&
methodDeclaration.Body.Statements.First() is ReturnStatement)
{
UnlockWith(methodDeclaration);
}
}
}
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (!methodDeclaration.Name.ToLower().Equals("main"))
{
if (!methodDeclaration.IsExtensionMethod &&
!methodDeclaration.HasModifier(Modifiers.Abstract))
{
if (methodDeclaration.Body.Statements.Count() == 1 &&
methodDeclaration.Body.Statements.First() is ReturnStatement)
{
UnlockWith(methodDeclaration);
}
}
}
return base.VisitMethodDeclaration(methodDeclaration, data);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
var lastParam = methodDeclaration.Parameters.LastOrDefault();
if (lastParam == null || lastParam.ParameterModifier != ParameterModifier.Params)
{
return;
}
var type = lastParam.Type as ComposedType;
if (type == null || !type.ArraySpecifiers.Any())
{
return;
}
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr == null)
{
return;
}
var baseMember = InheritanceHelper.GetBaseMember(rr.Member) as IMethod;
if (baseMember == null || baseMember.Parameters.Count == 0 || baseMember.Parameters.Last().IsParams)
{
return;
}
AddIssue(new CodeIssue(
lastParam.GetChildByRole(ParameterDeclaration.ParamsModifierRole),
ctx.TranslateString("'params' is always ignored in overrides"),
ctx.TranslateString("Remove 'params' modifier"),
script => {
var p = (ParameterDeclaration)lastParam.Clone();
p.ParameterModifier = ParameterModifier.None;
script.Replace(lastParam, p);
}
)
{
IssueMarker = IssueMarker.GrayOut
});
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (IsAchievementUnlocked) //Actually, all achievements should do this - it would improve performance and heaping a bit
{
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
if (!methodDeclaration.Name.ToLower().Equals("main"))
{
if (!methodDeclaration.IsExtensionMethod && !methodDeclaration.HasModifier(Modifiers.Abstract))
{
var returnType = methodDeclaration.ReturnType as PrimitiveType;
if (returnType != null && returnType.ToString() == "void")
{
UnlockWith(methodDeclaration);
}
}
}
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
var lastParam = methodDeclaration.Parameters.LastOrDefault();
if (lastParam == null || lastParam.ParameterModifier == ParameterModifier.Params)
{
return;
}
var type = lastParam.Type as ComposedType;
if (type == null || !type.ArraySpecifiers.Any())
{
return;
}
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr == null)
{
return;
}
var baseMember = InheritanceHelper.GetBaseMember(rr.Member) as IMethod;
if (baseMember == null || baseMember.Parameters.Count == 0 || !baseMember.Parameters.Last().IsParams)
{
return;
}
AddIssue(
lastParam.NameToken,
string.Format(ctx.TranslateString("Base method '{0}' has a 'params' modifier"), baseMember.FullName),
ctx.TranslateString("Add 'params' modifier"),
script => {
script.ChangeModifier(lastParam, ParameterModifier.Params);
}
);
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
methodDeclaration.Attributes.AcceptVisitor(this);
if (HasEntryPointSignature(methodDeclaration) || methodDeclaration.HasModifier(Modifiers.Public) || methodDeclaration.HasModifier(Modifiers.Protected))
{
return;
}
var eligibleParameters = methodDeclaration.Parameters
.Where(p => p.ParameterModifier != ParameterModifier.Out && p.ParameterModifier != ParameterModifier.Ref)
.ToList();
if (eligibleParameters.Count == 0)
{
return;
}
var declarationResolveResult = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (declarationResolveResult == null)
{
return;
}
var member = declarationResolveResult.Member;
if (member.IsOverride || member.IsOverridable || member.ImplementedInterfaceMembers.Any())
{
return;
}
var collector = new TypeCriteriaCollector(ctx);
methodDeclaration.AcceptVisitor(collector);
foreach (var parameter in eligibleParameters)
{
ProcessParameter(parameter, methodDeclaration.Body, collector);
}
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.ExternalAttribute")
{
return;
}
else if (rr.Type.FullName == "Bridge.InitAttribute")
{
InitPosition initPosition = InitPosition.After;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (InitPosition)argrr.ConstantValue;
}
}
}
if (initPosition > 0)
{
return;
}
}
}
}
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
var isEntryPoint = Helpers.IsEntryPointMethod(this.Emitter, this.MethodDeclaration);
var member_rr = (MemberResolveResult)this.Emitter.Resolver.ResolveNode(this.MethodDeclaration, this.Emitter);
string name = overloads.GetOverloadName(false, null, excludeTypeOnly: OverloadsCollection.ExcludeTypeParameterForDefinition(member_rr));
if (isEntryPoint)
{
this.Write(JS.Funcs.ENTRY_POINT_NAME);
}
else
{
this.Write(name);
}
this.WriteColon();
this.WriteFunction();
if (isEntryPoint)
{
this.Write(name);
this.WriteSpace();
}
else
{
var nm = Helpers.GetFunctionName(this.Emitter.AssemblyInfo.NamedFunctions, member_rr.Member, this.Emitter);
if (nm != null)
{
this.Write(nm);
this.WriteSpace();
}
}
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration.TypeParameters.Count > 0 && Helpers.IsIgnoreGeneric(methodDeclaration, this.Emitter) ? null : methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (YieldBlock.HasYield(methodDeclaration.Body))
{
new GeneratorBlock(this.Emitter, methodDeclaration).Emit();
}
else if (methodDeclaration.HasModifier(Modifiers.Async) || AsyncBlock.HasGoto(methodDeclaration.Body))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
this.WriteLines(script);
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.ExternalAttribute")
{
return;
}
else if (rr.Type.FullName == "Bridge.InitAttribute")
{
int initPosition = 0;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (int)argrr.ConstantValue;
}
}
}
if (initPosition > 0)
{
return;
}
}
}
}
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
string name = overloads.GetOverloadName(false, null, true);
if (Helpers.IsEntryPointMethod(this.Emitter, methodDeclaration))
{
name = JS.Fields.MAIN;
}
this.Write(name);
this.WriteColon();
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration.TypeParameters.Count > 0 && Helpers.IsIgnoreGeneric(methodDeclaration, this.Emitter) ? null : methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (YieldBlock.HasYield(methodDeclaration.Body))
{
new GeneratorBlock(this.Emitter, methodDeclaration).Emit();
}
else if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
this.WriteLines(script);
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
if (overloads.HasOverloads)
{
string name = overloads.GetOverloadName();
this.Write(name);
}
else
{
this.Write(this.Emitter.GetEntityName(methodDeclaration));
}
this.WriteColon();
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteFunction();
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
this.BeginBlock();
this.WriteReturn(true);
}
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
foreach (var line in script)
{
this.Write(line);
this.WriteNewLine();
}
this.EndBlock();
}
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteNewLine();
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.ExternalAttribute" || rr.Type.FullName == "Bridge.IgnoreAttribute")
{
return;
}
else if (rr.Type.FullName == "Bridge.InitAttribute")
{
int initPosition = 0;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (int)argrr.ConstantValue;
}
}
}
if (initPosition > 0)
{
return;
}
}
}
}
//this.EnsureComma();
this.EnsureNewLine();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
string name = overloads.GetOverloadName();
TransformCtx.CurClassMethodNames.Add(new TransformCtx.MethodInfo()
{
Name = name,
IsPrivate = methodDeclaration.HasModifier(Modifiers.Private),
});
this.Write(name);
this.WriteEqualsSign();
/*
* if (methodDeclaration.TypeParameters.Count > 0)
* {
* this.WriteFunction();
* this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
* this.WriteSpace();
* this.BeginBlock();
* this.WriteReturn(true);
* this.Write("Bridge.fn.bind(this, ");
* }*/
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration, true);
if (methodDeclaration.TypeParameters.Count > 0)
{
if (methodDeclaration.Parameters.Count > 0 || !methodDeclaration.HasModifier(Modifiers.Static))
{
this.WriteComma();
}
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
}
this.WriteCloseParentheses();
this.WriteSpace();
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
this.BeginFunctionBlock();
bool isYieldExists = YieldBlock.HasYield(methodDeclaration.Body);
IType yieldReturnType = null;
if (isYieldExists)
{
var returnResolveResult = this.Emitter.Resolver.ResolveNode(methodDeclaration.ReturnType, this.Emitter);
yieldReturnType = returnResolveResult.Type;
YieldBlock.EmitYield(this, yieldReturnType, methodDeclaration);
}
else
{
this.ConvertParamsToReferences(methodDeclaration.Parameters);
}
MarkTempVars();
methodDeclaration.Body.AcceptVisitor(this.Emitter);
EmitTempVars();
if (isYieldExists)
{
YieldBlock.EmitYieldReturn(this, yieldReturnType, methodDeclaration);
}
else
{
PrimitiveType returnType = methodDeclaration.ReturnType as PrimitiveType;
if (returnType != null)
{
if (returnType.KnownTypeCode == ICSharpCode.NRefactory.TypeSystem.KnownTypeCode.Void)
{
string refArgsString = GetRefArgsString(this.Emitter, methodDeclaration);
if (refArgsString != null)
{
this.WriteReturn(true);
this.Write(refArgsString);
this.WriteNewLine();
}
}
}
}
this.EndFunctionBlock();
}
/*
* if (methodDeclaration.TypeParameters.Count > 0)
* {
* this.Write(");");
* this.WriteNewLine();
* this.EndBlock();
* }*/
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (!methodDeclaration.HasModifier(Modifiers.Shared))
{
return;
}
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr == null || rr.IsError)
{
return;
}
var method = rr.Member as IMethod;
if (method == null)
{
return;
}
int arg = 0;
foreach (var param in methodDeclaration.Parameters)
{
var pr = ctx.Resolve(param) as LocalResolveResult;
if (pr == null)
{
continue;
}
foreach (var part in method.Parts)
{
if (param.Name != part.Parameters[arg].Name)
{
List <CodeAction> fixes = new List <CodeAction>();
foreach (var p2 in method.Parts)
{
if (param.Name != p2.Parameters[arg].Name)
{
int _arg = arg;
fixes.Add(new CodeAction(
string.Format(ctx.TranslateString("Rename to '{0}'"), p2.Parameters[_arg].Name),
s => {
s.Rename(pr.Variable, p2.Parameters[_arg].Name);
},
param
));
}
}
// TODO: Atm I think it makes only sense to offer a fix if the issue disappears
// which might not be the case here.
if (fixes.Count > 1)
{
fixes.Clear();
}
AddIssue(new CodeIssue(
param.NameToken,
ctx.TranslateString("Parameter name differs in partial method declaration"),
fixes
));
break;
}
}
arg++;
}
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.ExternalAttribute" || rr.Type.FullName == "Bridge.IgnoreAttribute")
{
return;
}
else if (rr.Type.FullName == "Bridge.InitAttribute")
{
int initPosition = 0;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (int)argrr.ConstantValue;
}
}
}
if (initPosition == 1) // Before
{
return;
}
}
}
}
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
string name = overloads.GetOverloadName();
this.Write(name);
this.WriteColon();
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteFunction();
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
this.BeginBlock();
this.WriteReturn(true);
this.Write("Bridge.fn.bind(this, ");
}
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
foreach (var line in script)
{
this.Write(line);
this.WriteNewLine();
}
this.EndBlock();
}
if (methodDeclaration.TypeParameters.Count > 0)
{
this.Write(");");
this.WriteNewLine();
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
private void WriteSignature(MethodDeclaration methodDeclaration, OverloadsCollection overloads, bool ignoreInterface, bool isInterface)
{
if (!isInterface && !methodDeclaration.HasModifier(Modifiers.Public))
{
return;
}
string name = overloads.GetOverloadName(ignoreInterface);
Write(name);
bool needComma = false;
var isGeneric = methodDeclaration.TypeParameters.Count > 0;
if (isGeneric)
{
Write("<");
foreach (var p in methodDeclaration.TypeParameters)
{
if (needComma)
{
WriteComma();
}
needComma = true;
Write(p.Name);
}
Write(">");
WriteOpenParentheses();
var comma = false;
foreach (var p in methodDeclaration.TypeParameters)
{
if (comma)
{
WriteComma();
}
Write(p.Name);
WriteColon();
WriteOpenBrace();
Write(JS.Fields.PROTOTYPE);
WriteColon();
Write(p.Name);
WriteCloseBrace();
comma = true;
}
}
else
{
WriteOpenParentheses();
}
if (needComma && methodDeclaration.Parameters.Count > 0)
{
WriteComma();
}
EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
WriteCloseParentheses();
WriteColon();
var retType = H5Types.ToTypeScriptName(methodDeclaration.ReturnType, Emitter);
Write(retType);
var resolveResult = Emitter.Resolver.ResolveNode(methodDeclaration.ReturnType);
if (resolveResult != null && (resolveResult.Type.IsReferenceType.HasValue && resolveResult.Type.IsReferenceType.Value || resolveResult.Type.IsKnownType(KnownTypeCode.NullableOfT)))
{
Write(" | null");
}
WriteSemiColon();
WriteNewLine();
}
private void HandleAttributes(List <string> list, KeyValuePair <string, List <MethodDeclaration> > methodGroup, MethodDeclaration method, out bool hasReadyAttribute)
{
hasReadyAttribute = false;
var isGenericType = this.IsGenericType();
var isGenericMethod = this.IsGenericMethod(method);
foreach (var attrSection in method.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var resolveResult = this.Emitter.Resolver.ResolveNode(attr, this.Emitter) as InvocationResolveResult;
if (resolveResult != null)
{
if (resolveResult.Type.FullName == CS.Attributes.READY_ATTRIBUTE_NAME)
{
hasReadyAttribute = true;
if (isGenericType || isGenericMethod)
{
LogAutoStartupWarning(method);
continue;
}
}
var baseTypes = resolveResult.Type.GetAllBaseTypes().ToArray();
if (baseTypes.Any(t => t.FullName == "Bridge.AdapterAttribute"))
{
if (methodGroup.Value.Count > 1)
{
throw new EmitterException(attr, "Overloaded method cannot be event handler");
}
var staticFlagField = resolveResult.Type.GetFields(f => f.Name == "StaticOnly");
if (staticFlagField.Count() > 0)
{
var staticValue = staticFlagField.First().ConstantValue;
if (staticValue is bool && ((bool)staticValue) && !method.HasModifier(Modifiers.Static))
{
throw new EmitterException(attr, resolveResult.Type.FullName + " can be applied for static methods only");
}
}
string eventName = methodGroup.Key;
var eventField = resolveResult.Type.GetFields(f => f.Name == "Event");
if (eventField.Count() > 0)
{
eventName = eventField.First().ConstantValue.ToString();
}
string format = null;
string formatName = this.StaticBlock ? "Format" : "FormatScope";
var formatField = resolveResult.Type.GetFields(f => f.Name == formatName, GetMemberOptions.IgnoreInheritedMembers);
if (formatField.Count() > 0)
{
format = formatField.First().ConstantValue.ToString();
}
else
{
for (int i = baseTypes.Length - 1; i >= 0; i--)
{
formatField = baseTypes[i].GetFields(f => f.Name == formatName);
if (formatField.Count() > 0)
{
format = formatField.First().ConstantValue.ToString();
break;
}
}
}
bool isCommon = false;
var commonField = resolveResult.Type.GetFields(f => f.Name == "IsCommonEvent");
if (commonField.Count() > 0)
{
isCommon = Convert.ToBoolean(commonField.First().ConstantValue);
}
if (isCommon)
{
var eventArg = attr.Arguments.First();
var primitiveArg = eventArg as ICSharpCode.NRefactory.CSharp.PrimitiveExpression;
if (primitiveArg != null)
{
eventName = primitiveArg.Value.ToString();
}
else
{
var memberArg = eventArg as MemberReferenceExpression;
if (memberArg != null)
{
var memberResolveResult = this.Emitter.Resolver.ResolveNode(memberArg, this.Emitter) as MemberResolveResult;
if (memberResolveResult != null)
{
eventName = this.Emitter.GetEntityName(memberResolveResult.Member);
}
}
}
}
int selectorIndex = isCommon ? 1 : 0;
string selector = null;
if (attr.Arguments.Count > selectorIndex)
{
selector = ((ICSharpCode.NRefactory.CSharp.PrimitiveExpression)(attr.Arguments.ElementAt(selectorIndex))).Value.ToString();
}
else
{
var resolvedmethod = resolveResult.Member as IMethod;
if (resolvedmethod.Parameters.Count > selectorIndex)
{
selector = resolvedmethod.Parameters[selectorIndex].ConstantValue.ToString();
}
}
if (attr.Arguments.Count > (selectorIndex + 1))
{
var memberResolveResult = this.Emitter.Resolver.ResolveNode(attr.Arguments.ElementAt(selectorIndex + 1), this.Emitter) as MemberResolveResult;
if (memberResolveResult != null && memberResolveResult.Member.Attributes.Count > 0)
{
var template = this.Emitter.Validator.GetAttribute(memberResolveResult.Member.Attributes, "Bridge.TemplateAttribute");
if (template != null)
{
selector = string.Format(template.PositionalArguments.First().ConstantValue.ToString(), selector);
}
}
}
else
{
var resolvedmethod = resolveResult.Member as IMethod;
if (resolvedmethod.Parameters.Count > (selectorIndex + 1))
{
var templateType = resolvedmethod.Parameters[selectorIndex + 1].Type;
var templateValue = Convert.ToInt32(resolvedmethod.Parameters[selectorIndex + 1].ConstantValue);
var fields = templateType.GetFields(f =>
{
var field = f as DefaultResolvedField;
if (field != null && field.ConstantValue != null && Convert.ToInt32(field.ConstantValue.ToString()) == templateValue)
{
return(true);
}
var field1 = f as DefaultUnresolvedField;
if (field1 != null && field1.ConstantValue != null && Convert.ToInt32(field1.ConstantValue.ToString()) == templateValue)
{
return(true);
}
return(false);
}, GetMemberOptions.IgnoreInheritedMembers);
if (fields.Count() > 0)
{
var template = this.Emitter.Validator.GetAttribute(fields.First().Attributes, "Bridge.TemplateAttribute");
if (template != null)
{
selector = string.Format(template.PositionalArguments.First().ConstantValue.ToString(), selector);
}
}
}
}
list.Add(string.Format(format, eventName, selector, this.Emitter.GetEntityName(method)));
}
}
}
}
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.ExternalAttribute" || rr.Type.FullName == "Bridge.IgnoreAttribute")
{
return;
}
else if (rr.Type.FullName == "Bridge.InitAttribute")
{
int initPosition = 0;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (int)argrr.ConstantValue;
}
}
}
if (initPosition > 0)
{
return;
}
}
}
}
//this.EnsureComma();
this.EnsureNewLine();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
string name = overloads.GetOverloadName();
TransformCtx.CurClassMethodNames.Add(new TransformCtx.MethodInfo() {
Name = name,
IsPrivate = methodDeclaration.HasModifier(Modifiers.Private),
});
this.Write(name);
this.WriteEqualsSign();
/*
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteFunction();
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
this.BeginBlock();
this.WriteReturn(true);
this.Write("Bridge.fn.bind(this, ");
}*/
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration, true);
if(methodDeclaration.TypeParameters.Count > 0) {
if(methodDeclaration.Parameters.Count > 0 || !methodDeclaration.HasModifier(Modifiers.Static)) {
this.WriteComma();
}
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
}
this.WriteCloseParentheses();
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
this.BeginFunctionBlock();
methodDeclaration.Body.AcceptVisitor(this.Emitter);
PrimitiveType returnType = methodDeclaration.ReturnType as PrimitiveType;
if(returnType != null) {
if(returnType.KnownTypeCode == ICSharpCode.NRefactory.TypeSystem.KnownTypeCode.Void) {
string refArgsString = GetRefArgsString(this.Emitter, methodDeclaration);
if(refArgsString != null) {
this.WriteReturn(true);
this.Write(refArgsString);
this.WriteNewLine();
}
}
}
this.EndFunctionBlock();
}
}
else
{
this.BeginBlock();
foreach (var line in script)
{
this.Write(line);
this.WriteNewLine();
}
this.EndBlock();
}
/*
if (methodDeclaration.TypeParameters.Count > 0)
{
this.Write(");");
this.WriteNewLine();
this.EndBlock();
}*/
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
if (methodDeclaration.HasModifier(Modifiers.Abstract) || this.HasInline(methodDeclaration))
{
return;
}
this.FixMethodParameters(methodDeclaration.Parameters, methodDeclaration.Body);
bool isStatic = methodDeclaration.HasModifier(Modifiers.Static);
Dictionary<string, List<MethodDeclaration>> dict = isStatic
? CurrentType.StaticMethods
: CurrentType.InstanceMethods;
var key = methodDeclaration.Name;
if (dict.ContainsKey(key))
{
dict[key].Add(methodDeclaration);
}
else
{
dict.Add(key, new List<MethodDeclaration>(new []{methodDeclaration}));
}
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
foreach (var attrSection in methodDeclaration.Attributes)
{
foreach (var attr in attrSection.Attributes)
{
var rr = this.Emitter.Resolver.ResolveNode(attr.Type, this.Emitter);
if (rr.Type.FullName == "Bridge.InitAttribute")
{
int initPosition = 0;
if (attr.HasArgumentList)
{
if (attr.Arguments.Any())
{
var argExpr = attr.Arguments.First();
var argrr = this.Emitter.Resolver.ResolveNode(argExpr, this.Emitter);
if (argrr.ConstantValue is int)
{
initPosition = (int)argrr.ConstantValue;
}
}
}
if (initPosition == 1) // Before
{
return;
}
}
}
}
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
if (overloads.HasOverloads)
{
string name = overloads.GetOverloadName();
this.Write(name);
}
else
{
this.Write(this.Emitter.GetEntityName(methodDeclaration));
}
this.WriteColon();
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteFunction();
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
this.BeginBlock();
this.WriteReturn(true);
this.Write("Bridge.fn.bind(this, ");
}
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
foreach (var line in script)
{
this.Write(line);
this.WriteNewLine();
}
this.EndBlock();
}
if (methodDeclaration.TypeParameters.Count > 0)
{
this.Write(");");
this.WriteNewLine();
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
private void WriteSignature(MethodDeclaration methodDeclaration, OverloadsCollection overloads, bool ignoreInterface, bool isInterface)
{
if (!isInterface && !methodDeclaration.HasModifier(Modifiers.Public))
{
return;
}
string name = overloads.GetOverloadName(ignoreInterface);
this.Write(name);
bool needComma = false;
var isGeneric = methodDeclaration.TypeParameters.Count > 0;
if (isGeneric)
{
this.Write("<");
foreach (var p in methodDeclaration.TypeParameters)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
this.Write(p.Name);
}
this.Write(">");
this.WriteOpenParentheses();
var comma = false;
foreach (var p in methodDeclaration.TypeParameters)
{
if (comma)
{
this.WriteComma();
}
this.Write(p.Name);
this.WriteColon();
this.WriteOpenBrace();
this.Write(JS.Fields.PROTOTYPE);
this.WriteColon();
this.Write(p.Name);
this.WriteCloseBrace();
comma = true;
}
}
else
{
this.WriteOpenParentheses();
}
if (needComma && methodDeclaration.Parameters.Count > 0)
{
this.WriteComma();
}
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
this.WriteCloseParentheses();
this.WriteColon();
var retType = BridgeTypes.ToTypeScriptName(methodDeclaration.ReturnType, this.Emitter);
this.Write(retType);
this.WriteSemiColon();
this.WriteNewLine();
}
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
base.VisitMethodDeclaration(methodDeclaration);
if (!methodDeclaration.HasModifier(Modifiers.Override))
{
return;
}
if (methodDeclaration.Body.Statements.Count != 1)
{
return;
}
var expr = methodDeclaration.Body.Statements.FirstOrNullObject();
//Debuger.WriteInFile(expr.FirstChild.ToString());
if (expr == null)
{
return;
}
var returnStatement = expr as ReturnStatement;
if (returnStatement != null)
{
var invocationExpression = returnStatement.Expression as InvocationExpression;
if (invocationExpression == null)
{
return;
}
var memberReferenceExpression = invocationExpression.Target as MemberReferenceExpression;
if (memberReferenceExpression == null ||
memberReferenceExpression.MemberName != methodDeclaration.Name ||
!(memberReferenceExpression.FirstChild is BaseReferenceExpression))
{
return;
}
if (methodDeclaration.Name == "GetHashCode" && !methodDeclaration.Parameters.Any())
{
var rr = ctx.Resolve(methodDeclaration) as MemberResolveResult;
if (rr != null && rr.Member.ReturnType.IsKnownType(KnownTypeCode.Int32))
{
if (rr.Member.DeclaringType.GetMethods(m => m.Name == "Equals" && m.IsOverride, GetMemberOptions.IgnoreInheritedMembers).Any())
{
return;
}
}
}
AddIssue(methodDeclaration);
}
var stmtExpr = expr as ExpressionStatement;
if (stmtExpr == null)
{
return;
}
var invocation = stmtExpr.Expression as InvocationExpression;
if (invocation != null)
{
var memberReferenceExpression = invocation.Target as MemberReferenceExpression;
if (memberReferenceExpression == null ||
memberReferenceExpression.MemberName != methodDeclaration.Name ||
!(memberReferenceExpression.FirstChild is BaseReferenceExpression))
{
return;
}
AddIssue(methodDeclaration);
}
}
protected void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
{
this.EnsureComma();
this.ResetLocals();
var prevMap = this.BuildLocalsMap();
var prevNamesMap = this.BuildLocalsNamesMap();
this.AddLocals(methodDeclaration.Parameters, methodDeclaration.Body);
var typeDef = this.Emitter.GetTypeDefinition();
var overloads = OverloadsCollection.Create(this.Emitter, methodDeclaration);
XmlToJsDoc.EmitComment(this, this.MethodDeclaration);
if (overloads.HasOverloads)
{
string name = overloads.GetOverloadName();
this.Write(name);
}
else
{
this.Write(this.Emitter.GetEntityName(methodDeclaration));
}
this.WriteColon();
if (methodDeclaration.TypeParameters.Count > 0)
{
this.WriteFunction();
this.EmitTypeParameters(methodDeclaration.TypeParameters, methodDeclaration);
this.WriteSpace();
this.BeginBlock();
this.WriteReturn(true);
this.Write("Bridge.fn.bind(this, ");
}
this.WriteFunction();
this.EmitMethodParameters(methodDeclaration.Parameters, methodDeclaration);
this.WriteSpace();
var script = this.Emitter.GetScript(methodDeclaration);
if (script == null)
{
if (methodDeclaration.HasModifier(Modifiers.Async))
{
new AsyncBlock(this.Emitter, methodDeclaration).Emit();
}
else
{
methodDeclaration.Body.AcceptVisitor(this.Emitter);
}
}
else
{
this.BeginBlock();
foreach (var line in script)
{
this.Write(line);
this.WriteNewLine();
}
this.EndBlock();
}
if (methodDeclaration.TypeParameters.Count > 0)
{
this.Write(");");
this.WriteNewLine();
this.EndBlock();
}
this.ClearLocalsMap(prevMap);
this.ClearLocalsNamesMap(prevNamesMap);
this.Emitter.Comma = true;
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if(IsAchievementUnlocked) //Actually, all achievements should do this - it would improve performance and heaping a bit
return base.VisitMethodDeclaration(methodDeclaration, data);
if (!methodDeclaration.Name.ToLower().Equals("main"))
{
if (!methodDeclaration.IsExtensionMethod && !methodDeclaration.HasModifier(Modifiers.Abstract))
{
var returnType = methodDeclaration.ReturnType as PrimitiveType;
if (returnType != null && returnType.ToString() == "void")
UnlockWith(methodDeclaration);
}
}
return base.VisitMethodDeclaration(methodDeclaration, data);
}
