public InlineArgumentsBlock(IEmitter emitter, ArgumentsInfo argsInfo, string inline)
: base(emitter, argsInfo.Expression)
{
this.Emitter = emitter;
this.ArgumentsInfo = argsInfo;
this.InlineCode = inline;
argsInfo.AddExtensionParam();
}
protected void VisitInvocationExpression()
{
InvocationExpression invocationExpression = this.InvocationExpression;
int pos = this.Emitter.Output.Length;
if (this.Emitter.IsForbiddenInvocation(invocationExpression))
{
throw new EmitterException(invocationExpression, "This method cannot be invoked directly");
}
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var oldAsyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
if (this.Emitter.IsAsync && !this.Emitter.AsyncExpressionHandling)
{
this.WriteAwaiters(invocationExpression);
this.Emitter.ReplaceAwaiterByVar = true;
this.Emitter.AsyncExpressionHandling = true;
}
Tuple<bool, bool, string> inlineInfo = this.Emitter.GetInlineCode(invocationExpression);
var argsInfo = new ArgumentsInfo(this.Emitter, invocationExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var argsCount = argsExpressions.Count();
if (inlineInfo != null)
{
bool isStaticMethod = inlineInfo.Item1;
bool isInlineMethod = inlineInfo.Item2;
string inlineScript = inlineInfo.Item3;
if (isInlineMethod)
{
if (invocationExpression.Arguments.Count > 0)
{
var code = invocationExpression.Arguments.First();
var inlineExpression = code as PrimitiveExpression;
if (inlineExpression == null)
{
throw new EmitterException(invocationExpression, "Only primitive expression can be inlined");
}
string value = inlineExpression.Value.ToString().Trim();
if (value.Length > 0)
{
value = InlineArgumentsBlock.ReplaceInlineArgs(this, inlineExpression.Value.ToString(), invocationExpression.Arguments.Skip(1).ToArray());
this.Write(value);
if (value[value.Length - 1] == ';')
{
this.Emitter.EnableSemicolon = false;
this.WriteNewLine();
}
}
else
{
// Empty string, emit nothing.
this.Emitter.EnableSemicolon = false;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
MemberReferenceExpression targetMemberRef = invocationExpression.Target as MemberReferenceExpression;
bool isBase = targetMemberRef != null && targetMemberRef.Target is BaseReferenceExpression;
if (!String.IsNullOrEmpty(inlineScript) && (isBase || invocationExpression.Target is IdentifierExpression))
{
argsInfo.ThisArgument = "this";
bool noThis = !inlineScript.Contains("{this}");
if (!isStaticMethod && noThis)
{
this.WriteThis();
this.WriteDot();
}
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineScript).Emit();
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
var targetResolve = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter);
var csharpInvocation = targetResolve as CSharpInvocationResolveResult;
MemberReferenceExpression targetMember = invocationExpression.Target as MemberReferenceExpression;
ResolveResult targetMemberResolveResult = null;
if (targetMember != null)
{
targetMemberResolveResult = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
}
if (targetMember != null)
{
var member = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
//var targetResolve = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
if (targetResolve != null)
{
InvocationResolveResult invocationResult;
bool isExtensionMethodInvocation = false;
if (csharpInvocation != null)
{
if (member != null && member.Type.Kind == TypeKind.Delegate && (csharpInvocation.Member.Name == "Invoke" || csharpInvocation.Member.Name == "BeginInvoke" || csharpInvocation.Member.Name == "EndInvoke") && !csharpInvocation.IsExtensionMethodInvocation)
{
throw new EmitterException(invocationExpression, "Delegate's 'Invoke' methods are not supported. Please use direct delegate invoke.");
}
if (csharpInvocation.IsExtensionMethodInvocation)
{
invocationResult = csharpInvocation;
isExtensionMethodInvocation = true;
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (string.IsNullOrWhiteSpace(inline) && isNative)
{
invocationResult = null;
}
}
}
else
{
invocationResult = null;
}
if (this.IsEmptyPartialInvoking(csharpInvocation.Member as IMethod) || IsConditionallyRemoved(invocationExpression, csharpInvocation.Member))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null && (this.IsEmptyPartialInvoking(invocationResult.Member as IMethod) || IsConditionallyRemoved(invocationExpression, invocationResult.Member)))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
if (invocationResult == null)
{
invocationResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as InvocationResolveResult;
}
if (invocationResult != null)
{
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (isExtensionMethodInvocation)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else if (!isNative)
{
var overloads = OverloadsCollection.Create(this.Emitter, resolvedMethod);
string name = BridgeTypes.ToJsName(resolvedMethod.DeclaringType, this.Emitter) + "." + overloads.GetOverloadName();
var isIgnoreClass = resolvedMethod.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(resolvedMethod.DeclaringTypeDefinition);
this.Write(name);
if (!isIgnoreClass && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
this.WriteThisExtension(invocationExpression.Target);
if (invocationExpression.Arguments.Count > 0)
{
this.WriteComma();
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
if (!string.IsNullOrWhiteSpace(inline) || !isNative)
{
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (isNative)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else
{
argsExpressions.First().AcceptVisitor(this.Emitter);
this.WriteDot();
string name = this.Emitter.GetEntityName(resolvedMethod);
this.Write(name);
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions.Skip(1), paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
}
}
var proto = false;
if (targetMember != null && targetMember.Target is BaseReferenceExpression)
{
var rr = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter) as MemberResolveResult;
if (rr != null)
{
proto = rr.IsVirtualCall;
/*var method = rr.Member as IMethod;
if (method != null && method.IsVirtual)
{
proto = true;
}
else
{
var prop = rr.Member as IProperty;
if (prop != null && prop.IsVirtual)
{
proto = true;
}
}*/
}
}
if (proto)
{
var baseType = this.Emitter.GetBaseMethodOwnerTypeDefinition(targetMember.MemberName, targetMember.TypeArguments.Count);
var method = invocationExpression.GetParent<MethodDeclaration>();
bool isIgnore = this.Emitter.Validator.IsIgnoreType(baseType);
if (isIgnore)
{
//throw (System.Exception)this.Emitter.CreateException(targetMember.Target, "Cannot call base method, because parent class code is ignored");
}
bool needComma = false;
var resolveResult = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
string name = null;
if (this.Emitter.TypeInfo.GetBaseTypes(this.Emitter).Any())
{
name = BridgeTypes.ToJsName(this.Emitter.TypeInfo.GetBaseClass(this.Emitter), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
string baseMethod;
if (resolveResult is InvocationResolveResult)
{
InvocationResolveResult invocationResult = (InvocationResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, invocationResult.Member).GetOverloadName();
}
else if (resolveResult is MemberResolveResult)
{
MemberResolveResult memberResult = (MemberResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, memberResult.Member).GetOverloadName();
}
else
{
baseMethod = targetMember.MemberName;
baseMethod = this.Emitter.AssemblyInfo.PreserveMemberCase ? baseMethod : Object.Net.Utilities.StringUtils.ToLowerCamelCase(baseMethod);
}
this.Write(name, ".prototype.", baseMethod);
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteDot();
this.Write("call");
this.WriteOpenParentheses();
this.WriteThis();
needComma = true;
foreach (var arg in argsExpressions)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
arg.AcceptVisitor(this.Emitter);
}
this.WriteCloseParentheses();
}
else
{
var dynamicResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as DynamicInvocationResolveResult;
if (dynamicResolveResult != null)
{
var group = dynamicResolveResult.Target as MethodGroupResolveResult;
if (group != null && group.Methods.Count() > 1)
{
throw new EmitterException(invocationExpression, "Cannot compile this dynamic invocation because there are two or more method overloads with the same parameter count. To work around this limitation, assign the dynamic value to a non-dynamic variable before use or call a method with different parameter count");
}
}
var targetResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression.Target, this.Emitter);
var invocationResolveResult = targetResolveResult as MemberResolveResult;
IMethod method = null;
if (invocationResolveResult != null)
{
method = invocationResolveResult.Member as IMethod;
}
if (this.IsEmptyPartialInvoking(method) || IsConditionallyRemoved(invocationExpression, method))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
bool isIgnore = method != null && method.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition);
bool needExpand = false;
if (method != null)
{
string paramsName = null;
var paramsParam = method.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsName = paramsParam.Name;
}
if (paramsName != null)
{
if (csharpInvocation != null && !csharpInvocation.IsExpandedForm)
{
needExpand = true;
}
}
}
int count = this.Emitter.Writers.Count;
invocationExpression.Target.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count > count)
{
var tuple = this.Emitter.Writers.Pop();
if (method != null && method.IsExtensionMethod)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
}
new InlineArgumentsBlock(this.Emitter, argsInfo, tuple.Item1).Emit();
var result = this.Emitter.Output.ToString();
this.Emitter.Output = tuple.Item2;
this.Emitter.IsNewLine = tuple.Item3;
this.Write(result);
}
else
{
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
if (needExpand && isIgnore)
{
this.Write(".apply");
}
this.WriteOpenParentheses();
if (needExpand && isIgnore)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
var thisArg = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
this.Write(thisArg);
this.WriteComma();
if (argsExpressions.Length > 1)
{
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions.Take(argsExpressions.Length - 1).ToArray(), paramsArg, invocationExpression).Emit();
this.WriteCloseBracket();
this.Write(".concat(");
new ExpressionListBlock(this.Emitter, new Expression[]{argsExpressions[argsExpressions.Length - 1]}, paramsArg, invocationExpression).Emit();
this.Write(")");
}
else
{
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
}
}
else
{
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
}
this.WriteCloseParentheses();
}
}
Helpers.CheckValueTypeClone(this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter), invocationExpression, this, pos);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
}
protected virtual void EmitInlineExpressionList(ArgumentsInfo argsInfo, string inline)
{
IEnumerable<NamedParamExpression> expressions = argsInfo.NamedExpressions;
IEnumerable<TypeParamExpression> typeParams = argsInfo.TypeArguments;
this.Write("");
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = this.Emitter.Writers.Count;
string key = m.Groups[2].Value;
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
bool ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
string paramsName = null;
if (argsInfo.ResolveResult != null)
{
var paramsParam = argsInfo.ResolveResult.Member.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsName = paramsParam.Name;
}
}
if (modifier == "array")
{
ignoreArray = false;
}
StringBuilder oldSb = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
if (key == "this" || key == argsInfo.ThisName || (key == "0" && argsInfo.IsExtensionMethod))
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
this.Write(thisValue);
}
}
else
{
IList<Expression> exprs = this.GetExpressionsByKey(expressions, key);
if (exprs.Count > 0)
{
if (exprs.Count > 1 || paramsName == key)
{
if (exprs.Count == 1 && exprs[0] != null && exprs[0].Parent != null)
{
var exprrr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter);
if (exprrr.Type.Kind == TypeKind.Array)
{
ignoreArray = true;
}
}
if (!ignoreArray)
{
this.Write("[");
}
if (exprs.Count == 1 && exprs[0] == null)
{
this.Write("null");
}
else
{
new ExpressionListBlock(this.Emitter, exprs, null).Emit();
}
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (exprs[0] != null)
{
var writer = this.SaveWriter();
this.NewWriter();
exprs[0].AcceptVisitor(this.Emitter);
s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
s = "null";
}
this.Write(this.WriteIndentToString(s));
}
}
else if (typeParams != null)
{
var type = this.GetAstTypeByKey(typeParams, key);
if (type != null)
{
type.AcceptVisitor(this.Emitter);
}
else
{
var iType = this.GetITypeByKey(typeParams, key);
if (iType != null)
{
new CastBlock(this.Emitter, iType).Emit();
}
}
}
}
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
}
string replacement = this.Emitter.Output.ToString();
this.Emitter.Output = oldSb;
return replacement;
});
this.Write(inline);
}
protected virtual void EmitInlineExpressionList(ArgumentsInfo argsInfo, string inline)
{
IEnumerable<NamedParamExpression> expressions = argsInfo.NamedExpressions;
IEnumerable<TypeParamExpression> typeParams = argsInfo.TypeArguments;
this.Write("");
bool needExpand = false;
string paramsName = null;
IType paramsType = null;
if (argsInfo.ResolveResult != null)
{
var paramsParam = argsInfo.ResolveResult.Member.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsName = paramsParam.Name;
paramsType = paramsParam.Type;
}
}
if (paramsName != null)
{
var matches = _formatArg.Matches(inline);
bool ignoreArray = false;
foreach (Match m in matches)
{
if (m.Groups[2].Value == paramsName)
{
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
if (modifier == "array")
{
ignoreArray = false;
}
break;
}
}
if (argsInfo.ResolveResult is CSharpInvocationResolveResult)
{
needExpand = !((CSharpInvocationResolveResult) argsInfo.ResolveResult).IsExpandedForm;
}
if (needExpand && ignoreArray)
{
IList<Expression> exprs = this.GetExpressionsByKey(expressions, paramsName);
if (exprs.Count == 1 && exprs[0] != null && exprs[0].Parent != null)
{
var exprrr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter);
if (exprrr.Type.Kind == TypeKind.Array)
{
var match = _inlineMethod.Match(inline);
if (match.Success)
{
string target = null;
var methodName = match.Groups[1].Value;
if (methodName.Contains("."))
{
target = methodName.LeftOfRightmostOf('.');
}
string args = match.Groups[2].Value;
StringBuilder sb = new StringBuilder();
sb.Append(methodName);
sb.Append(".apply(");
sb.Append(target ?? "null");
if (args.Contains(","))
{
sb.Append(", [");
sb.Append(args.LeftOfRightmostOf(',').Trim());
sb.Append("].concat(");
sb.Append(args.RightOfRightmostOf(',').Trim());
sb.Append(")");
}
else
{
sb.Append(",");
sb.Append(args);
}
sb.Append(")");
inline = inline.Remove(match.Index, match.Length);
inline = inline.Insert(match.Index, sb.ToString());
}
}
}
}
}
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = this.Emitter.Writers.Count;
string key = m.Groups[2].Value;
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
bool ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
if (modifier == "array")
{
ignoreArray = false;
}
StringBuilder oldSb = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
if (key == "this" || key == argsInfo.ThisName || (key == "0" && argsInfo.IsExtensionMethod))
{
if (modifier == "type")
{
AstNode node = null;
if (argsInfo.ThisArgument is AstNode)
{
node = (AstNode) argsInfo.ThisArgument;
}
else
{
node = argsInfo.Expression;
}
if (node != null)
{
var rr = this.Emitter.Resolver.ResolveNode(node, this.Emitter);
var type = rr.Type;
if (rr is MemberResolveResult)
{
type = ((MemberResolveResult) rr).TargetResult.Type;
}
this.Write(BridgeTypes.ToJsName(type, this.Emitter));
}
}
else
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
this.Write(thisValue);
}
}
}
else
{
IList<Expression> exprs = this.GetExpressionsByKey(expressions, key);
if (exprs.Count > 0)
{
if (modifier == "type")
{
if (paramsName == key && paramsType != null)
{
this.Write(BridgeTypes.ToJsName(paramsType, this.Emitter));
}
else
{
var rr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter);
this.Write(BridgeTypes.ToJsName(rr.Type, this.Emitter));
}
}
else if (exprs.Count > 1 || paramsName == key)
{
if (needExpand)
{
ignoreArray = true;
}
if (!ignoreArray)
{
this.Write("[");
}
if (exprs.Count == 1 && exprs[0] == null)
{
this.Write("null");
}
else
{
new ExpressionListBlock(this.Emitter, exprs, null).Emit();
}
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (exprs[0] != null)
{
var writer = this.SaveWriter();
this.NewWriter();
exprs[0].AcceptVisitor(this.Emitter);
s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
s = "null";
}
this.Write(this.WriteIndentToString(s));
}
}
else if (typeParams != null)
{
var type = this.GetAstTypeByKey(typeParams, key);
if (type != null)
{
type.AcceptVisitor(this.Emitter);
}
else
{
var iType = this.GetITypeByKey(typeParams, key);
if (iType != null)
{
new CastBlock(this.Emitter, iType).Emit();
}
}
}
}
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
}
string replacement = this.Emitter.Output.ToString();
this.Emitter.Output = oldSb;
return replacement;
});
this.Write(inline);
}
protected void VisitInvocationExpression()
{
InvocationExpression invocationExpression = this.InvocationExpression;
if (this.Emitter.IsForbiddenInvocation(invocationExpression))
{
throw new EmitterException(invocationExpression, "This method cannot be invoked directly");
}
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var oldAsyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
if (this.Emitter.IsAsync && !this.Emitter.AsyncExpressionHandling)
{
this.WriteAwaiters(invocationExpression);
this.Emitter.ReplaceAwaiterByVar = true;
this.Emitter.AsyncExpressionHandling = true;
}
Tuple <bool, bool, string> inlineInfo = this.Emitter.GetInlineCode(invocationExpression);
var argsInfo = new ArgumentsInfo(this.Emitter, invocationExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var argsCount = argsExpressions.Count();
if (inlineInfo != null)
{
bool isStaticMethod = inlineInfo.Item1;
bool isInlineMethod = inlineInfo.Item2;
string inlineScript = inlineInfo.Item3;
if (isInlineMethod)
{
if (invocationExpression.Arguments.Count > 0)
{
var code = invocationExpression.Arguments.First();
var inlineExpression = code as PrimitiveExpression;
if (inlineExpression == null)
{
throw new EmitterException(invocationExpression, "Only primitive expression can be inlined");
}
string value = inlineExpression.Value.ToString().Trim();
if (value.Length > 0)
{
value = InlineArgumentsBlock.ReplaceInlineArgs(this, inlineExpression.Value.ToString(), invocationExpression.Arguments.Skip(1).ToArray());
this.Write(value);
if (value[value.Length - 1] == ';')
{
this.Emitter.EnableSemicolon = false;
this.WriteNewLine();
}
}
else
{
// Empty string, emit nothing.
this.Emitter.EnableSemicolon = false;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
MemberReferenceExpression targetMemberRef = invocationExpression.Target as MemberReferenceExpression;
bool isBase = targetMemberRef != null && targetMemberRef.Target is BaseReferenceExpression;
if (!String.IsNullOrEmpty(inlineScript) && (isBase || invocationExpression.Target is IdentifierExpression))
{
argsInfo.ThisArgument = "this";
bool noThis = !inlineScript.Contains("{this}");
if (!isStaticMethod && noThis)
{
this.WriteThis();
this.WriteDot();
}
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineScript).Emit();
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
MemberReferenceExpression targetMember = invocationExpression.Target as MemberReferenceExpression;
ResolveResult targetMemberResolveResult = null;
if (targetMember != null)
{
targetMemberResolveResult = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
}
if (targetMember != null)
{
var member = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
//var targetResolve = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
var targetResolve = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter);
if (targetResolve != null)
{
var csharpInvocation = targetResolve as CSharpInvocationResolveResult;
InvocationResolveResult invocationResult;
bool isExtensionMethodInvocation = false;
if (csharpInvocation != null)
{
if (member != null && member.Type.Kind == TypeKind.Delegate && !csharpInvocation.IsExtensionMethodInvocation)
{
throw new EmitterException(invocationExpression, "Delegate's methods are not supported. Please use direct delegate invoke.");
}
if (csharpInvocation.IsExtensionMethodInvocation)
{
invocationResult = csharpInvocation;
isExtensionMethodInvocation = true;
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (string.IsNullOrWhiteSpace(inline) && isNative)
{
invocationResult = null;
}
}
}
else
{
invocationResult = null;
}
if (this.IsEmptyPartialInvoking(csharpInvocation.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null && this.IsEmptyPartialInvoking(invocationResult.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
if (invocationResult == null)
{
invocationResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as InvocationResolveResult;
}
if (invocationResult != null)
{
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (isExtensionMethodInvocation)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else if (!isNative)
{
var overloads = OverloadsCollection.Create(this.Emitter, resolvedMethod);
string name = BridgeTypes.ToJsName(resolvedMethod.DeclaringType, this.Emitter) + "." + overloads.GetOverloadName();
var isIgnoreClass = resolvedMethod.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(resolvedMethod.DeclaringTypeDefinition);
this.Write(name);
if (!isIgnoreClass && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
this.WriteThisExtension(invocationExpression.Target);
if (invocationExpression.Arguments.Count > 0)
{
this.WriteComma();
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
if (!string.IsNullOrWhiteSpace(inline) || !isNative)
{
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (isNative)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else
{
argsExpressions.First().AcceptVisitor(this.Emitter);
this.WriteDot();
string name = this.Emitter.GetEntityName(resolvedMethod);
this.Write(name);
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions.Skip(1), paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
}
}
var proto = false;
if (targetMember != null && targetMember.Target is BaseReferenceExpression)
{
var rr = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter) as MemberResolveResult;
if (rr != null)
{
proto = rr.IsVirtualCall;
/*var method = rr.Member as IMethod;
* if (method != null && method.IsVirtual)
* {
* proto = true;
* }
* else
* {
* var prop = rr.Member as IProperty;
*
* if (prop != null && prop.IsVirtual)
* {
* proto = true;
* }
* }*/
}
}
if (proto)
{
var baseType = this.Emitter.GetBaseMethodOwnerTypeDefinition(targetMember.MemberName, targetMember.TypeArguments.Count);
var method = invocationExpression.GetParent <MethodDeclaration>();
bool isIgnore = this.Emitter.Validator.IsIgnoreType(baseType);
if (isIgnore)
{
//throw (System.Exception)this.Emitter.CreateException(targetMember.Target, "Cannot call base method, because parent class code is ignored");
}
bool needComma = false;
var resolveResult = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
string name = null;
if (this.Emitter.TypeInfo.GetBaseTypes(this.Emitter).Any())
{
name = BridgeTypes.ToJsName(this.Emitter.TypeInfo.GetBaseClass(this.Emitter), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
string baseMethod;
if (resolveResult is InvocationResolveResult)
{
InvocationResolveResult invocationResult = (InvocationResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, invocationResult.Member).GetOverloadName();
}
else if (resolveResult is MemberResolveResult)
{
MemberResolveResult memberResult = (MemberResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, memberResult.Member).GetOverloadName();
}
else
{
baseMethod = targetMember.MemberName;
baseMethod = this.Emitter.AssemblyInfo.PreserveMemberCase ? baseMethod : Object.Net.Utilities.StringUtils.ToLowerCamelCase(baseMethod);
}
this.Write(name, ".prototype.", baseMethod);
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteDot();
this.Write("call");
this.WriteOpenParentheses();
this.WriteThis();
needComma = true;
foreach (var arg in argsExpressions)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
arg.AcceptVisitor(this.Emitter);
}
this.WriteCloseParentheses();
}
else
{
var dynamicResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as DynamicInvocationResolveResult;
if (dynamicResolveResult != null)
{
var group = dynamicResolveResult.Target as MethodGroupResolveResult;
if (group != null && group.Methods.Count() > 1)
{
throw new EmitterException(invocationExpression, "Cannot compile this dynamic invocation because there are two or more method overloads with the same parameter count. To work around this limitation, assign the dynamic value to a non-dynamic variable before use or call a method with different parameter count");
}
}
var targetResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression.Target, this.Emitter);
var invocationResolveResult = targetResolveResult as MemberResolveResult;
IMethod method = null;
if (invocationResolveResult != null)
{
method = invocationResolveResult.Member as IMethod;
}
if (this.IsEmptyPartialInvoking(method))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
int count = this.Emitter.Writers.Count;
invocationExpression.Target.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count > count)
{
var tuple = this.Emitter.Writers.Pop();
if (method != null && method.IsExtensionMethod)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
}
new InlineArgumentsBlock(this.Emitter, argsInfo, tuple.Item1).Emit();
var result = this.Emitter.Output.ToString();
this.Emitter.Output = tuple.Item2;
this.Emitter.IsNewLine = tuple.Item3;
this.Write(result);
}
else
{
var isIgnore = false;
if (method != null && method.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition))
{
isIgnore = true;
}
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
}
Helpers.CheckValueTypeClone(this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter), invocationExpression, this);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
}
protected virtual void EmitInlineExpressionList(ArgumentsInfo argsInfo, string inline)
{
IEnumerable <NamedParamExpression> expressions = argsInfo.NamedExpressions;
IEnumerable <TypeParamExpression> typeParams = argsInfo.TypeArguments;
Expression paramsArg = argsInfo.ParamsExpression;
var matches = _formatArg.Matches(inline);
this.Write("");
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = this.Emitter.Writers.Count;
string key = m.Groups[2].Value;
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
bool ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
StringBuilder oldSb = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
if (key == "this" || key == argsInfo.ThisName || (key == "0" && argsInfo.IsExtensionMethod))
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
this.Write(thisValue);
}
}
else
{
IList <Expression> exprs = this.GetExpressionsByKey(expressions, key);
if (exprs.Count > 0)
{
if (exprs.Count > 1)
{
if (!ignoreArray)
{
this.Write("[");
}
new ExpressionListBlock(this.Emitter, exprs, null).Emit();
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
var writer = this.SaveWriter();
this.NewWriter();
exprs[0].AcceptVisitor(this.Emitter);
var s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
this.Write(s);
}
}
else if (typeParams != null)
{
var type = this.GetAstTypeByKey(typeParams, key);
if (type != null)
{
type.AcceptVisitor(this.Emitter);
}
else
{
var iType = this.GetITypeByKey(typeParams, key);
if (iType != null)
{
new CastBlock(this.Emitter, iType).Emit();
}
}
}
}
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
}
string replacement = this.Emitter.Output.ToString();
this.Emitter.Output = oldSb;
return(replacement);
});
this.Write(inline);
}
protected virtual void EmitArrayAccess(IndexerExpression indexerExpression)
{
string targetVar = null;
bool writeTargetVar = false;
bool isStatement = false;
string valueVar = null;
var resolveResult = this.Emitter.Resolver.ResolveNode(indexerExpression, this.Emitter);
if (this.Emitter.IsAssignment && this.Emitter.AssignmentType != AssignmentOperatorType.Assign)
{
writeTargetVar = true;
}
else if (this.Emitter.IsUnaryAccessor)
{
writeTargetVar = true;
isStatement = indexerExpression.Parent is UnaryOperatorExpression && indexerExpression.Parent.Parent is ExpressionStatement;
if (NullableType.IsNullable(resolveResult.Type))
{
isStatement = false;
}
if (!isStatement)
{
this.WriteOpenParentheses();
}
}
if (writeTargetVar)
{
var targetrr = this.Emitter.Resolver.ResolveNode(indexerExpression.Target, this.Emitter);
var memberTargetrr = targetrr as MemberResolveResult;
bool isField = memberTargetrr != null && memberTargetrr.Member is IField && (memberTargetrr.TargetResult is ThisResolveResult || memberTargetrr.TargetResult is LocalResolveResult);
if (!(targetrr is ThisResolveResult || targetrr is LocalResolveResult || isField))
{
targetVar = this.GetTempVarName();
this.Write(targetVar);
this.Write(" = ");
}
}
if (this.Emitter.IsUnaryAccessor && !isStatement && targetVar == null)
{
valueVar = this.GetTempVarName();
this.Write(valueVar);
this.Write(" = ");
}
var oldIsAssignment = this.Emitter.IsAssignment;
var oldUnary = this.Emitter.IsUnaryAccessor;
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
if (targetVar != null)
{
if (this.Emitter.IsUnaryAccessor && !isStatement)
{
this.WriteComma(false);
valueVar = this.GetTempVarName();
this.Write(valueVar);
this.Write(" = ");
this.Write(targetVar);
}
else
{
this.WriteSemiColon();
this.WriteNewLine();
this.Write(targetVar);
}
}
this.WriteDot();
var argsInfo = new ArgumentsInfo(this.Emitter, indexerExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
if (!this.Emitter.IsAssignment)
{
if (this.Emitter.IsUnaryAccessor)
{
bool isDecimal = Helpers.IsDecimalType(resolveResult.Type, this.Emitter.Resolver);
bool isNullable = NullableType.IsNullable(resolveResult.Type);
if (isStatement)
{
this.Write("set");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteComma(false);
if (isDecimal)
{
if (isNullable)
{
this.Write("Bridge.Nullable.lift1");
this.WriteOpenParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.WriteScript("inc");
}
else
{
this.WriteScript("dec");
}
this.WriteComma();
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
this.WriteCloseParentheses();
}
else
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
this.WriteDot();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("inc");
}
else
{
this.Write("dec");
}
this.WriteOpenCloseParentheses();
}
}
else
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("+");
}
else
{
this.Write("-");
}
this.Write("1");
}
this.WriteCloseParentheses();
}
else
{
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
this.WriteComma();
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("set");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteComma(false);
if (isDecimal)
{
if (isNullable)
{
this.Write("Bridge.Nullable.lift1");
this.WriteOpenParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment ||
this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.WriteScript("inc");
}
else
{
this.WriteScript("dec");
}
this.WriteComma();
this.Write(valueVar);
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
this.WriteCloseParentheses();
}
else
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
this.WriteDot();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment ||
this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("inc");
}
else
{
this.Write("dec");
}
this.WriteOpenCloseParentheses();
}
}
else
{
this.Write(valueVar);
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("+");
}
else
{
this.Write("-");
}
this.Write("1");
}
this.WriteCloseParentheses();
this.WriteComma();
var isPreOp = this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment ||
this.Emitter.UnaryOperatorType == UnaryOperatorType.Decrement;
if (isPreOp)
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
}
else
{
this.Write(valueVar);
}
this.WriteCloseParentheses();
if (valueVar != null)
{
this.RemoveTempVar(valueVar);
}
}
if (targetVar != null)
{
this.RemoveTempVar(targetVar);
}
}
else
{
this.Write("get");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.WriteCloseParentheses();
}
}
else
{
if (this.Emitter.AssignmentType != AssignmentOperatorType.Assign)
{
var oldWriter = this.SaveWriter();
this.NewWriter();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
var paramsStr = this.Emitter.Output.ToString();
this.RestoreWriter(oldWriter);
if (targetVar != null)
{
this.PushWriter(string.Concat(
"set([",
paramsStr,
"],",
targetVar,
".get([",
paramsStr,
"]){0})"), () => { this.RemoveTempVar(targetVar); });
}
else
{
oldWriter = this.SaveWriter();
this.NewWriter();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
var trg = this.Emitter.Output.ToString();
this.RestoreWriter(oldWriter);
this.PushWriter(string.Concat(
"set([",
paramsStr,
"],",
trg,
".get([",
paramsStr,
"]){0})"));
}
}
else
{
this.Write("set");
this.WriteOpenParentheses();
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseBracket();
this.PushWriter(", {0})");
}
}
}
protected void VisitInvocationExpression()
{
InvocationExpression invocationExpression = this.InvocationExpression;
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var oldAsyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
if (this.Emitter.IsAsync && !this.Emitter.AsyncExpressionHandling)
{
this.WriteAwaiters(invocationExpression);
this.Emitter.ReplaceAwaiterByVar = true;
this.Emitter.AsyncExpressionHandling = true;
}
Tuple<bool, bool, string> inlineInfo = this.Emitter.GetInlineCode(invocationExpression);
var argsInfo = new ArgumentsInfo(this.Emitter, invocationExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var argsCount = argsExpressions.Count();
if (inlineInfo != null)
{
bool isStaticMethod = inlineInfo.Item1;
bool isInlineMethod = inlineInfo.Item2;
string inlineScript = inlineInfo.Item3;
if (isInlineMethod)
{
if (invocationExpression.Arguments.Count == 1)
{
var code = invocationExpression.Arguments.First();
var inlineExpression = code as PrimitiveExpression;
if (inlineExpression == null)
{
throw new EmitterException(invocationExpression, "Only primitive expression can be inlined");
}
string value = inlineExpression.Value.ToString().Trim();
if (value.Length > 0)
{
this.Write(inlineExpression.Value);
if (value[value.Length - 1] == ';')
{
this.Emitter.EnableSemicolon = false;
this.WriteNewLine();
}
}
else
{
// Empty string, emit nothing.
this.Emitter.EnableSemicolon = false;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (!String.IsNullOrEmpty(inlineScript) && invocationExpression.Target is IdentifierExpression)
{
argsInfo.ThisArgument = "this";
bool noThis = !inlineScript.Contains("{this}");
if (!isStaticMethod && noThis)
{
this.WriteThis();
this.WriteDot();
}
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineScript).Emit();
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
MemberReferenceExpression targetMember = invocationExpression.Target as MemberReferenceExpression;
ResolveResult targetMemberResolveResult = null;
if (targetMember != null)
{
targetMemberResolveResult = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
}
if (targetMember != null)
{
var member = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
if (member != null && member.Type.Kind == TypeKind.Delegate)
{
throw new EmitterException(invocationExpression, "Delegate's methods are not supported. Please use direct delegate invoke.");
}
var targetResolve = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
if (targetResolve != null)
{
var csharpInvocation = targetResolve as CSharpInvocationResolveResult;
InvocationResolveResult invocationResult;
bool isExtensionMethodInvocation = false;
if (csharpInvocation != null)
{
if (csharpInvocation.IsExtensionMethodInvocation)
{
invocationResult = csharpInvocation;
isExtensionMethodInvocation = true;
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (string.IsNullOrWhiteSpace(inline) && isNative)
{
invocationResult = null;
}
}
}
else
{
invocationResult = null;
}
if (this.IsEmptyPartialInvoking(csharpInvocation.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null && this.IsEmptyPartialInvoking(invocationResult.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
if (invocationResult == null)
{
invocationResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as InvocationResolveResult;
}
if (invocationResult != null)
{
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (isExtensionMethodInvocation)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else if (!isNative)
{
string name = BridgeTypes.ToJsName(resolvedMethod.DeclaringType, this.Emitter) + "." + this.Emitter.GetEntityName(resolvedMethod);
var isIgnoreClass = resolvedMethod.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(resolvedMethod.DeclaringTypeDefinition);
this.Write(name);
if (!isIgnoreClass && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
this.WriteThisExtension(invocationExpression.Target);
if (argsCount > 0)
{
this.WriteComma();
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
if (!string.IsNullOrWhiteSpace(inline) || !isNative)
{
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (isNative)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else
{
argsExpressions.First().AcceptVisitor(this.Emitter);
this.WriteDot();
string name = this.Emitter.GetEntityName(resolvedMethod);
this.Write(name);
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions.Skip(1), paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
}
}
var proto = false;
if (targetMember != null && targetMember.Target is BaseReferenceExpression)
{
var rr = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter) as MemberResolveResult;
if (rr != null)
{
var method = rr.Member as IMethod;
if (method != null && method.IsVirtual)
{
proto = true;
}
else
{
var prop = rr.Member as IProperty;
if (prop != null && prop.IsVirtual)
{
proto = true;
}
}
}
}
if (proto)
{
var baseType = this.Emitter.GetBaseMethodOwnerTypeDefinition(targetMember.MemberName, targetMember.TypeArguments.Count);
var method = invocationExpression.GetParent<MethodDeclaration>();
bool isIgnore = this.Emitter.Validator.IsIgnoreType(baseType);
if (isIgnore)
{
throw (Exception)this.Emitter.CreateException(targetMember.Target, "Cannot call base method, because parent class code is ignored");
}
bool needComma = false;
var resolveResult = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
string name = null;
if (this.Emitter.TypeInfo.TypeDeclaration.BaseTypes.Any())
{
name = BridgeTypes.ToJsName(this.Emitter.TypeInfo.TypeDeclaration.BaseTypes.First(), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
if (resolveResult != null && resolveResult is InvocationResolveResult)
{
InvocationResolveResult invocationResult = (InvocationResolveResult)resolveResult;
this.Write(name, ".prototype.", this.Emitter.GetEntityName(invocationResult.Member));
}
else
{
string baseMethod = targetMember.MemberName;
this.Write(name, ".prototype.", this.Emitter.AssemblyInfo.PreserveMemberCase ? baseMethod : Object.Net.Utilities.StringUtils.ToLowerCamelCase(baseMethod));
}
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteDot();
this.Write("call");
this.WriteOpenParentheses();
this.WriteThis();
needComma = true;
foreach (var arg in argsExpressions)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
arg.AcceptVisitor(this.Emitter);
}
this.WriteCloseParentheses();
}
else
{
var targetResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression.Target, this.Emitter);
var invocationResolveResult = targetResolveResult as MemberResolveResult;
IMethod method = null;
if (invocationResolveResult != null)
{
method = invocationResolveResult.Member as IMethod;
}
if (this.IsEmptyPartialInvoking(method))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
int count = this.Emitter.Writers.Count;
invocationExpression.Target.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count > count)
{
var tuple = this.Emitter.Writers.Pop();
if (method != null && method.IsExtensionMethod)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
}
new InlineArgumentsBlock(this.Emitter, argsInfo, tuple.Item1).Emit();
var result = this.Emitter.Output.ToString();
this.Emitter.Output = tuple.Item2;
this.Emitter.IsNewLine = tuple.Item3;
this.Write(result);
}
else
{
var isIgnore = false;
if (method != null && method.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition))
{
isIgnore = true;
}
if (!isIgnore && argsInfo.HasTypeArguments)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression).Emit();
this.WriteCloseParentheses();
}
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
}
protected virtual void EmitInlineExpressionList(ArgumentsInfo argsInfo, string inline, bool asRef = false, bool isNull = false, bool?definition = null)
{
IEnumerable <NamedParamExpression> expressions = argsInfo.NamedExpressions;
IEnumerable <TypeParamExpression> typeParams = argsInfo.TypeArguments;
bool addClose = false;
this.Write("");
if (asRef)
{
var withoutTypeParams = this.Method.TypeArguments.Count > 0 &&
this.Method.TypeArguments.All(t => t.Kind != TypeKind.TypeParameter);
if (definition.HasValue)
{
withoutTypeParams = !definition.Value;
}
if (withoutTypeParams && (!this.Method.IsStatic || this.Method.IsExtensionMethod && this.TargetResolveResult is ThisResolveResult) && (this.TargetResolveResult is ThisResolveResult || this.TargetResolveResult == null) && (inline.Contains("{this}") || this.Method.IsStatic || this.Method.IsExtensionMethod && inline.Contains("{" + this.Method.Parameters.First().Name + "}")))
{
this.Write(JS.Funcs.BRIDGE_BIND);
this.Write("(this, ");
addClose = true;
}
this.Write("function (");
this.EmitMethodParameters(this.Method, this.Method.Parameters, withoutTypeParams ? null : this.Method.TypeParameters, isNull);
this.Write(") { return ");
}
bool needExpand = false;
bool expandParams = false;
string paramsName = null;
IType paramsType = null;
int paramsIndex = 0;
if (argsInfo.ResolveResult != null)
{
var paramsParam = argsInfo.ResolveResult.Member.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsIndex = argsInfo.ResolveResult.Member.Parameters.IndexOf(paramsParam);
paramsName = paramsParam.Name;
paramsType = paramsParam.Type;
}
expandParams = argsInfo.ResolveResult.Member.Attributes.Any(a => a.AttributeType.FullName == "Bridge.ExpandParamsAttribute");
}
else if (argsInfo.Method != null)
{
var paramsParam = argsInfo.Method.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsIndex = argsInfo.Method.Parameters.IndexOf(paramsParam);
paramsName = paramsParam.Name;
paramsType = paramsParam.Type;
}
expandParams = argsInfo.Method.Attributes.Any(a => a.AttributeType.FullName == "Bridge.ExpandParamsAttribute");
}
if (paramsName != null)
{
var matches = _formatArg.Matches(inline);
bool ignoreArray = false;
foreach (Match m in matches)
{
if (m.Groups[2].Value == paramsName)
{
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
if (modifier == "array")
{
ignoreArray = false;
}
break;
}
}
if (expandParams)
{
ignoreArray = true;
}
if (argsInfo.ResolveResult is CSharpInvocationResolveResult)
{
needExpand = !((CSharpInvocationResolveResult)argsInfo.ResolveResult).IsExpandedForm;
}
if (needExpand && ignoreArray && !asRef)
{
IList <Expression> exprs = this.GetExpressionsByKey(expressions, paramsName);
if (exprs.Count == 1 && exprs[0] != null && exprs[0].Parent != null)
{
var exprrr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter);
if (exprrr.Type.Kind == TypeKind.Array)
{
var match = _inlineMethod.Match(inline);
if (match.Success)
{
string target = null;
var methodName = match.Groups[1].Value;
if (methodName.Contains("."))
{
target = methodName.LeftOfRightmostOf('.');
}
string args = match.Groups[2].Value;
StringBuilder sb = new StringBuilder();
sb.Append(methodName);
sb.Append(".");
sb.Append(JS.Funcs.APPLY);
sb.Append("(");
sb.Append(target ?? "null");
if (args.Contains(","))
{
sb.Append(", [");
sb.Append(args.LeftOfRightmostOf(',').Trim());
sb.Append("].concat(");
sb.Append(args.RightOfRightmostOf(',').Trim());
sb.Append(")");
}
else
{
sb.Append(",");
sb.Append(args);
}
sb.Append(")");
inline = inline.Remove(match.Index, match.Length);
inline = inline.Insert(match.Index, sb.ToString());
}
}
}
}
}
var r = InlineArgumentsBlock._formatArg.Matches(inline);
List <Match> keyMatches = new List <Match>();
foreach (Match keyMatch in r)
{
keyMatches.Add(keyMatch);
}
var tempVars = new Dictionary <string, string>();
var tempMap = new Dictionary <string, string>();
inline = _formatArg.Replace(inline, delegate(Match m)
{
if (this.IgnoreRange != null && m.Index >= this.IgnoreRange[0] && m.Index <= this.IgnoreRange[1])
{
return(m.Value);
}
int count = this.Emitter.Writers.Count;
string key = m.Groups[2].Value;
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
bool ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
bool isSimple = false;
var tempKey = key + ":" + modifier ?? "";
if (tempMap.ContainsKey(tempKey))
{
return(tempMap[tempKey]);
}
if (modifier == "array")
{
ignoreArray = false;
}
StringBuilder oldSb = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
if (asRef)
{
if (Regex.IsMatch(key, "^\\d+$"))
{
var index = int.Parse(key);
key = this.Method.Parameters[index].Name;
}
if (modifier == "type")
{
this.Write(JS.Funcs.BRIDGE_GET_TYPE + "(");
}
if (key == "this")
{
if (isNull)
{
isSimple = true;
this.Write(JS.Vars.T);
}
else if (this.Method.IsExtensionMethod && this.TargetResolveResult is TypeResolveResult)
{
isSimple = true;
this.WriteParamName(this.Method.Parameters.First().Name);
}
else if (argsInfo.Expression is MemberReferenceExpression)
{
var trg = ((MemberReferenceExpression)argsInfo.Expression).Target;
if (trg is BaseReferenceExpression)
{
isSimple = true;
this.Write("this");
}
else
{
isSimple = this.IsSimpleExpression(trg);
trg.AcceptVisitor(this.Emitter);
}
}
else
{
this.Write("this");
}
}
else if (this.Method.IsExtensionMethod && key == this.Method.Parameters.First().Name)
{
if (this.TargetResolveResult is TypeResolveResult)
{
isSimple = true;
this.WriteParamName(key);
}
else if (argsInfo.Expression is MemberReferenceExpression)
{
var trg = ((MemberReferenceExpression)argsInfo.Expression).Target;
if (trg is BaseReferenceExpression)
{
isSimple = true;
this.Write("this");
}
else
{
isSimple = this.IsSimpleExpression(trg);
trg.AcceptVisitor(this.Emitter);
}
}
else
{
isSimple = true;
this.WriteParamName(key);
}
}
else if (paramsName == key && !ignoreArray)
{
isSimple = true;
this.Write(JS.Types.ARRAY + "." + JS.Fields.PROTOTYPE + "." + JS.Funcs.SLICE);
this.WriteCall("(" + JS.Vars.ARGUMENTS + ", " + paramsIndex + ")");
}
else
{
isSimple = true;
this.WriteParamName(key);
}
if (modifier == "type")
{
this.Write(")");
}
}
else if (key == "this" || key == argsInfo.ThisName || (key == "0" && argsInfo.IsExtensionMethod))
{
if (modifier == "type")
{
AstNode node = null;
if (argsInfo.ThisArgument is AstNode)
{
node = (AstNode)argsInfo.ThisArgument;
}
else
{
node = argsInfo.Expression;
}
if (node != null)
{
var rr = this.Emitter.Resolver.ResolveNode(node, this.Emitter);
var type = rr.Type;
var mrr = rr as MemberResolveResult;
if (mrr != null && mrr.Member.ReturnType.Kind != TypeKind.Enum)
{
type = mrr.TargetResult.Type;
}
bool needName = this.NeedName(type);
if (needName)
{
isSimple = true;
this.Write(BridgeTypes.ToJsName(type, this.Emitter));
}
else
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
this.Write(JS.Funcs.BRIDGE_GET_TYPE + "(" + thisValue + ")");
}
}
}
}
else
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
isSimple = true;
this.Write(thisValue);
}
}
}
else
{
IList <Expression> exprs = this.GetExpressionsByKey(expressions, key);
if (exprs.Count > 0)
{
if (modifier == "type")
{
IType type = null;
if (paramsName == key && paramsType != null)
{
type = paramsType;
}
else
{
var rr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter);
type = rr.Type;
}
bool needName = this.NeedName(type);
this.WriteGetType(needName, type, exprs[0], modifier);
isSimple = true;
}
else if (modifier == "tmp")
{
var tmpVarName = this.GetTempVarName();
var nameExpr = exprs[0] as PrimitiveExpression;
if (nameExpr == null)
{
throw new EmitterException(exprs[0], "Primitive expression is required");
}
Emitter.NamedTempVariables[nameExpr.LiteralValue] = tmpVarName;
Write(tmpVarName);
isSimple = true;
}
else if (modifier == "version")
{
var versionTypeExp = exprs != null && exprs.Any() ? exprs[0] : null;
var versionType = 0;
if (versionTypeExp != null)
{
var versionTypePrimitiveExp = versionTypeExp as PrimitiveExpression;
if (versionTypePrimitiveExp != null && versionTypePrimitiveExp.Value is int)
{
versionType = (int)versionTypePrimitiveExp.Value;
}
else
{
var rr = this.Emitter.Resolver.ResolveNode(versionTypeExp, this.Emitter);
if (rr != null && rr.ConstantValue != null && rr.ConstantValue is int)
{
versionType = (int)rr.ConstantValue;
}
}
}
string version;
if (versionType == 0)
{
version = this.Emitter.Translator.GetVersionContext().Assembly.Version;
}
else
{
version = this.Emitter.Translator.GetVersionContext().Compiler.Version;
}
Write("\"", version, "\"");
isSimple = true;
}
else if (modifier == "gettmp")
{
var nameExpr = exprs[0] as PrimitiveExpression;
if (nameExpr == null)
{
throw new EmitterException(exprs[0], "Primitive expression is required");
}
if (!Emitter.NamedTempVariables.ContainsKey(nameExpr.LiteralValue))
{
throw new EmitterException(exprs[0], "Primitive expression is required");
}
var tmpVarName = Emitter.NamedTempVariables[nameExpr.LiteralValue];
Write(tmpVarName);
isSimple = true;
}
else if (modifier == "body")
{
var lambdaExpr = exprs[0] as LambdaExpression;
if (lambdaExpr == null)
{
throw new EmitterException(exprs[0], "Lambda expression is required");
}
var writer = this.SaveWriter();
this.NewWriter();
lambdaExpr.Body.AcceptVisitor(this.Emitter);
var s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
this.Write(this.WriteIndentToString(s));
}
else if (exprs.Count > 1 || paramsName == key)
{
if (needExpand)
{
ignoreArray = true;
}
if (!ignoreArray)
{
this.Write("[");
}
if (exprs.Count == 1 && exprs[0] == null)
{
isSimple = true;
this.Write("null");
}
else
{
new ExpressionListBlock(this.Emitter, exprs, null, null, 0).Emit();
}
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (exprs[0] != null)
{
var writer = this.SaveWriter();
this.NewWriter();
var directExpr = exprs[0] as DirectionExpression;
if (directExpr != null)
{
var rr = this.Emitter.Resolver.ResolveNode(exprs[0], this.Emitter) as ByReferenceResolveResult;
if (rr != null && !(rr.ElementResult is LocalResolveResult))
{
this.Write(JS.Funcs.BRIDGE_REF + "(");
this.Emitter.IsRefArg = true;
exprs[0].AcceptVisitor(this.Emitter);
this.Emitter.IsRefArg = false;
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
count = this.Emitter.Writers.Count;
}
this.Write(")");
}
else
{
exprs[0].AcceptVisitor(this.Emitter);
}
}
else if (modifier == "plain")
{
var an = exprs[0] as AnonymousTypeCreateExpression;
if (an == null)
{
this.Write(JS.Funcs.BRIDGE_TOPLAIN);
this.WriteOpenParentheses();
exprs[0].AcceptVisitor(this.Emitter);
this.Write(")");
}
else
{
new AnonymousTypeCreateBlock(this.Emitter, an, true).Emit();
}
}
else
{
isSimple = this.IsSimpleExpression(exprs[0]);
exprs[0].AcceptVisitor(this.Emitter);
}
s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
isSimple = true;
s = "null";
}
this.Write(this.WriteIndentToString(s));
}
}
else if (this.ArgumentsInfo.Attribute != null)
{
var results = this.GetResolveResultByKey(key);
if (results.Count > 1 || paramsName == key)
{
if (needExpand)
{
ignoreArray = true;
}
if (!ignoreArray)
{
this.Write("[");
}
if (exprs.Count == 1 && results[0].IsCompileTimeConstant && results[0].ConstantValue == null)
{
isSimple = true;
this.Write("null");
}
else
{
bool needComma = false;
foreach (ResolveResult item in results)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
isSimple = this.IsSimpleResolveResult(item);
AttributeCreateBlock.WriteResolveResult(item, this);
}
}
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (results[0] != null)
{
var writer = this.SaveWriter();
this.NewWriter();
isSimple = this.IsSimpleResolveResult(results[0]);
AttributeCreateBlock.WriteResolveResult(results[0], this);
s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
s = "null";
}
this.Write(this.WriteIndentToString(s));
}
}
else if (this.ArgumentsInfo.StringArguments != null)
{
var results = this.GetStringArgumentByKey(key);
if (results.Count > 1 || paramsName == key)
{
if (needExpand)
{
ignoreArray = true;
}
if (!ignoreArray)
{
this.Write("[");
}
bool needComma = false;
foreach (string item in results)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
this.Write(item);
}
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (results[0] != null)
{
s = results[0];
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
s = "null";
}
this.Write(s);
}
}
else if (typeParams != null)
{
var type = this.GetAstTypeByKey(typeParams, key);
if (type != null)
{
if (modifier == "default" || modifier == "defaultFn")
{
var def = Inspector.GetDefaultFieldValue(type, this.Emitter.Resolver);
this.GetDefaultValue(def, modifier);
}
else
{
type.AcceptVisitor(this.Emitter);
}
}
else
{
var iType = this.GetTypeByKey(typeParams, key);
if (iType != null)
{
if (modifier == "default" || modifier == "defaultFn")
{
var def = Inspector.GetDefaultFieldValue(iType.IType, iType.AstType);
this.GetDefaultValue(def, modifier);
}
else
{
new CastBlock(this.Emitter, iType.IType).Emit();
}
}
}
}
}
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
}
string replacement = this.Emitter.Output.ToString();
this.Emitter.Output = oldSb;
if (!isSimple && keyMatches.Count(keyMatch =>
{
string key1 = keyMatch.Groups[2].Value;
string modifier1 = keyMatch.Groups[1].Success ? keyMatch.Groups[4].Value : null;
return(key == key1 && modifier1 == modifier);
}) > 1)
{
var t = this.GetTempVarName();
tempVars.Add(t, replacement);
tempMap[tempKey] = t;
return(t);
}
return(replacement);
});
if (tempVars.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append("(");
foreach (var tempVar in tempVars)
{
sb.Append(tempVar.Key);
sb.Append("=");
sb.Append(tempVar.Value);
sb.Append(", ");
}
sb.Append(inline);
sb.Append(")");
inline = sb.ToString();
}
this.Write(inline);
if (asRef)
{
this.Write("; }");
if (addClose)
{
this.Write(")");
}
}
}
protected void VisitInvocationExpression()
{
InvocationExpression invocationExpression = this.InvocationExpression;
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var oldAsyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
if (this.Emitter.IsAsync && !this.Emitter.AsyncExpressionHandling)
{
this.WriteAwaiters(invocationExpression);
this.Emitter.ReplaceAwaiterByVar = true;
this.Emitter.AsyncExpressionHandling = true;
}
Tuple <bool, bool, string> inlineInfo = this.Emitter.GetInlineCode(invocationExpression);
var argsInfo = new ArgumentsInfo(this.Emitter, invocationExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var argsCount = argsExpressions.Count();
if (inlineInfo != null)
{
bool isStaticMethod = inlineInfo.Item1;
bool isInlineMethod = inlineInfo.Item2;
string inlineScript = inlineInfo.Item3;
if (isInlineMethod)
{
if (invocationExpression.Arguments.Count == 1)
{
var code = invocationExpression.Arguments.First();
var inlineExpression = code as PrimitiveExpression;
if (inlineExpression == null)
{
throw (Exception)this.Emitter.CreateException(invocationExpression, "Only primitive expression can be inlined");
}
string value = inlineExpression.Value.ToString().Trim();
if (value.Length > 0)
{
this.Write(inlineExpression.Value);
if (value[value.Length - 1] == ';')
{
this.Emitter.EnableSemicolon = false;
this.WriteNewLine();
}
}
else
{
// Empty string, emit nothing.
this.Emitter.EnableSemicolon = false;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (!String.IsNullOrEmpty(inlineScript) && invocationExpression.Target is IdentifierExpression)
{
argsInfo.ThisArgument = "this";
bool noThis = !inlineScript.Contains("{this}");
if (!isStaticMethod && noThis)
{
this.WriteThis();
this.WriteDot();
}
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineScript).Emit();
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
MemberReferenceExpression targetMember = invocationExpression.Target as MemberReferenceExpression;
if (targetMember != null)
{
var member = this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter);
if (member != null && member.Type.Kind == TypeKind.Delegate)
{
throw (Exception)this.Emitter.CreateException(invocationExpression, "Delegate's methods are not supported. Please use direct delegate invoke.");
}
var targetResolve = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
if (targetResolve != null)
{
var csharpInvocation = targetResolve as CSharpInvocationResolveResult;
InvocationResolveResult invocationResult;
if (csharpInvocation != null)
{
invocationResult = csharpInvocation.IsExtensionMethodInvocation ? csharpInvocation : null;
if (this.IsEmptyPartialInvoking(csharpInvocation.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null && this.IsEmptyPartialInvoking(invocationResult.Member as IMethod))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
if (invocationResult != null)
{
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else
{
string name = this.Emitter.ShortenTypeName(Helpers.ReplaceSpecialChars(resolvedMethod.DeclaringType.FullName)) + "." + this.Emitter.GetEntityName(resolvedMethod);
var isIgnoreClass = resolvedMethod.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(resolvedMethod.DeclaringTypeDefinition);
this.Write(name);
if (!isIgnoreClass && argsInfo.TypeArguments != null && argsInfo.TypeArguments.Length > 0)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
this.WriteThisExtension(invocationExpression.Target);
if (argsCount > 0)
{
this.WriteComma();
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseParentheses();
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
}
if (targetMember != null && targetMember.Target is BaseReferenceExpression)
{
var baseType = this.Emitter.GetBaseMethodOwnerTypeDefinition(targetMember.MemberName, targetMember.TypeArguments.Count);
var method = invocationExpression.GetParent <MethodDeclaration>();
bool isIgnore = this.Emitter.Validator.IsIgnoreType(baseType);
if (isIgnore)
{
throw (Exception)this.Emitter.CreateException(targetMember.Target, "Cannot call base method, because parent class code is ignored");
}
string baseMethod = Helpers.GetScriptName(targetMember, false);
bool needComma = false;
var resolveResult = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
if (resolveResult != null && resolveResult is InvocationResolveResult)
{
InvocationResolveResult invocationResult = (InvocationResolveResult)resolveResult;
this.Write(this.Emitter.ShortenTypeName(Helpers.GetScriptFullName(baseType)), ".prototype.", this.Emitter.GetEntityName(invocationResult.Member));
}
else
{
this.Write(this.Emitter.ShortenTypeName(Helpers.GetScriptFullName(baseType)), ".prototype.", this.Emitter.ChangeCase ? Object.Net.Utilities.StringUtils.ToLowerCamelCase(baseMethod) : baseMethod);
}
if (!isIgnore && argsInfo.TypeArguments != null && argsInfo.TypeArguments.Length > 0)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteDot();
this.Write("call");
this.WriteOpenParentheses();
this.WriteThis();
needComma = true;
foreach (var arg in argsExpressions)
{
if (needComma)
{
this.WriteComma();
}
needComma = true;
arg.AcceptVisitor(this.Emitter);
}
this.WriteCloseParentheses();
}
else
{
var targetResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression.Target, this.Emitter);
var invocationResolveResult = targetResolveResult as MemberResolveResult;
IMethod method = null;
if (invocationResolveResult != null)
{
method = invocationResolveResult.Member as IMethod;
}
if (this.IsEmptyPartialInvoking(method))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
int count = this.Emitter.Writers.Count;
invocationExpression.Target.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count > count)
{
var tuple = this.Emitter.Writers.Pop();
new InlineArgumentsBlock(this.Emitter, argsInfo, tuple.Item1).Emit();
var result = this.Emitter.Output.ToString();
this.Emitter.Output = tuple.Item2;
this.Emitter.IsNewLine = tuple.Item3;
this.Write(result);
}
else
{
var isIgnore = false;
if (method != null && method.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition))
{
isIgnore = true;
}
if (!isIgnore && argsInfo.TypeArguments != null && argsInfo.TypeArguments.Length > 0)
{
this.WriteOpenParentheses();
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.WriteCloseParentheses();
}
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseParentheses();
}
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
}
protected void VisitInvocationExpression()
{
InvocationExpression invocationExpression = this.InvocationExpression;
int pos = this.Emitter.Output.Length;
if (this.Emitter.IsForbiddenInvocation(invocationExpression))
{
throw new EmitterException(invocationExpression, "This method cannot be invoked directly");
}
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var oldAsyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
if (this.Emitter.IsAsync && !this.Emitter.AsyncExpressionHandling)
{
this.WriteAwaiters(invocationExpression);
this.Emitter.ReplaceAwaiterByVar = true;
this.Emitter.AsyncExpressionHandling = true;
}
Tuple <bool, bool, string> inlineInfo = this.Emitter.GetInlineCode(invocationExpression);
var argsInfo = new ArgumentsInfo(this.Emitter, invocationExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var targetResolve = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter);
var csharpInvocation = targetResolve as CSharpInvocationResolveResult;
MemberReferenceExpression targetMember = invocationExpression.Target as MemberReferenceExpression;
bool isObjectLiteral = csharpInvocation != null && csharpInvocation.Member.DeclaringTypeDefinition != null?this.Emitter.Validator.IsObjectLiteral(csharpInvocation.Member.DeclaringTypeDefinition) : false;
var interceptor = this.Emitter.Plugins.OnInvocation(this, this.InvocationExpression, targetResolve as InvocationResolveResult);
if (interceptor.Cancel)
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
if (!string.IsNullOrEmpty(interceptor.Replacement))
{
this.Write(interceptor.Replacement);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
if (inlineInfo != null)
{
bool isStaticMethod = inlineInfo.Item1;
bool isInlineMethod = inlineInfo.Item2;
string inlineScript = inlineInfo.Item3;
if (isInlineMethod)
{
if (invocationExpression.Arguments.Count > 0)
{
var code = invocationExpression.Arguments.First();
var inlineExpression = code as PrimitiveExpression;
if (inlineExpression == null)
{
throw new EmitterException(invocationExpression, "Only primitive expression can be inlined");
}
string value = inlineExpression.Value.ToString().Trim();
if (value.Length > 0)
{
value = InlineArgumentsBlock.ReplaceInlineArgs(this, inlineExpression.Value.ToString(), invocationExpression.Arguments.Skip(1).ToArray());
this.Write(value);
value = value.Trim();
if (value[value.Length - 1] == ';' || value.EndsWith("*/", StringComparison.InvariantCulture) || value.StartsWith("//"))
{
this.Emitter.EnableSemicolon = false;
this.WriteNewLine();
}
}
else
{
// Empty string, emit nothing.
this.Emitter.EnableSemicolon = false;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
MemberReferenceExpression targetMemberRef = invocationExpression.Target as MemberReferenceExpression;
bool isBase = targetMemberRef != null && targetMemberRef.Target is BaseReferenceExpression;
if (!String.IsNullOrEmpty(inlineScript) && (isBase || invocationExpression.Target is IdentifierExpression))
{
argsInfo.ThisArgument = "this";
bool noThis = !inlineScript.Contains("{this}");
if (inlineScript.StartsWith("<self>"))
{
noThis = false;
inlineScript = inlineScript.Substring(6);
}
if (!noThis)
{
Emitter.ThisRefCounter++;
}
if (!isStaticMethod && noThis)
{
this.WriteThis();
this.WriteDot();
}
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineScript).Emit();
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
if (targetMember != null || isObjectLiteral)
{
var member = targetMember != null?this.Emitter.Resolver.ResolveNode(targetMember.Target, this.Emitter) : null;
if (targetResolve != null)
{
InvocationResolveResult invocationResult;
bool isExtensionMethodInvocation = false;
if (csharpInvocation != null)
{
if (member != null && member.Type.Kind == TypeKind.Delegate && (/*csharpInvocation.Member.Name == "Invoke" || */ csharpInvocation.Member.Name == "BeginInvoke" || csharpInvocation.Member.Name == "EndInvoke") && !csharpInvocation.IsExtensionMethodInvocation)
{
throw new EmitterException(invocationExpression, "Delegate's 'Invoke' methods are not supported. Please use direct delegate invoke.");
}
if (csharpInvocation.IsExtensionMethodInvocation)
{
invocationResult = csharpInvocation;
isExtensionMethodInvocation = true;
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && resolvedMethod.IsExtensionMethod)
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (string.IsNullOrWhiteSpace(inline) && isNative)
{
invocationResult = null;
}
}
}
else
{
invocationResult = null;
}
if (this.IsEmptyPartialInvoking(csharpInvocation.Member as IMethod) || IsConditionallyRemoved(invocationExpression, csharpInvocation.Member))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else
{
invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null && (this.IsEmptyPartialInvoking(invocationResult.Member as IMethod) || IsConditionallyRemoved(invocationExpression, invocationResult.Member)))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
if (invocationResult == null)
{
invocationResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as InvocationResolveResult;
}
if (invocationResult != null)
{
var resolvedMethod = invocationResult.Member as IMethod;
if (resolvedMethod != null && (resolvedMethod.IsExtensionMethod || isObjectLiteral))
{
string inline = this.Emitter.GetInline(resolvedMethod);
bool isNative = this.IsNativeMethod(resolvedMethod);
if (isExtensionMethodInvocation || isObjectLiteral)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else if (!isNative)
{
var overloads = OverloadsCollection.Create(this.Emitter, resolvedMethod);
if (isObjectLiteral && !resolvedMethod.IsStatic && resolvedMethod.DeclaringType.Kind == TypeKind.Interface)
{
this.Write("Bridge.getType(");
this.WriteThisExtension(invocationExpression.Target);
this.Write(").");
}
else
{
string name = BridgeTypes.ToJsName(resolvedMethod.DeclaringType, this.Emitter) + ".";
this.Write(name);
}
if (isObjectLiteral && !resolvedMethod.IsStatic)
{
this.Write(JS.Fields.PROTOTYPE + "." + overloads.GetOverloadName() + "." + JS.Funcs.CALL);
}
else
{
this.Write(overloads.GetOverloadName());
}
var isIgnoreClass = resolvedMethod.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(resolvedMethod.DeclaringTypeDefinition);
int openPos = this.Emitter.Output.Length;
this.WriteOpenParentheses();
this.Emitter.Comma = false;
if (isObjectLiteral && !resolvedMethod.IsStatic)
{
this.WriteThisExtension(invocationExpression.Target);
this.Emitter.Comma = true;
}
if (!isIgnoreClass && !Helpers.IsIgnoreGeneric(resolvedMethod, this.Emitter) && argsInfo.HasTypeArguments)
{
this.EnsureComma(false);
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
this.Emitter.Comma = true;
}
if (!isObjectLiteral && resolvedMethod.IsStatic)
{
this.EnsureComma(false);
this.WriteThisExtension(invocationExpression.Target);
this.Emitter.Comma = true;
}
if (invocationExpression.Arguments.Count > 0)
{
this.EnsureComma(false);
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression, openPos).Emit();
this.WriteCloseParentheses();
}
if (!string.IsNullOrWhiteSpace(inline) || !isNative)
{
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
else if (isNative)
{
if (!string.IsNullOrWhiteSpace(inline))
{
this.Write("");
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
new InlineArgumentsBlock(this.Emitter, argsInfo, inline).Emit();
}
else
{
argsExpressions.First().AcceptVisitor(this.Emitter);
this.WriteDot();
string name = this.Emitter.GetEntityName(resolvedMethod);
this.Write(name);
int openPos = this.Emitter.Output.Length;
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions.Skip(1), paramsArg, invocationExpression, openPos).Emit();
this.WriteCloseParentheses();
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
}
}
}
}
var proto = false;
if (targetMember != null && targetMember.Target is BaseReferenceExpression)
{
var rr = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter) as MemberResolveResult;
if (rr != null)
{
proto = rr.IsVirtualCall;
/*var method = rr.Member as IMethod;
* if (method != null && method.IsVirtual)
* {
* proto = true;
* }
* else
* {
* var prop = rr.Member as IProperty;
*
* if (prop != null && prop.IsVirtual)
* {
* proto = true;
* }
* }*/
}
}
if (proto)
{
var baseType = this.Emitter.GetBaseMethodOwnerTypeDefinition(targetMember.MemberName, targetMember.TypeArguments.Count);
bool isIgnore = this.Emitter.Validator.IsIgnoreType(baseType);
if (isIgnore)
{
//throw (System.Exception)this.Emitter.CreateException(targetMember.Target, "Cannot call base method, because parent class code is ignored");
}
bool needComma = false;
var resolveResult = this.Emitter.Resolver.ResolveNode(targetMember, this.Emitter);
string name = null;
if (this.Emitter.TypeInfo.GetBaseTypes(this.Emitter).Any())
{
name = BridgeTypes.ToJsName(this.Emitter.TypeInfo.GetBaseClass(this.Emitter), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
string baseMethod;
bool isIgnoreGeneric = false;
if (resolveResult is InvocationResolveResult)
{
InvocationResolveResult invocationResult = (InvocationResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, invocationResult.Member).GetOverloadName();
isIgnoreGeneric = Helpers.IsIgnoreGeneric(invocationResult.Member, this.Emitter);
}
else if (resolveResult is MemberResolveResult)
{
MemberResolveResult memberResult = (MemberResolveResult)resolveResult;
baseMethod = OverloadsCollection.Create(this.Emitter, memberResult.Member).GetOverloadName();
isIgnoreGeneric = Helpers.IsIgnoreGeneric(memberResult.Member, this.Emitter);
}
else
{
baseMethod = targetMember.MemberName;
baseMethod = this.Emitter.AssemblyInfo.PreserveMemberCase ? baseMethod : Object.Net.Utilities.StringUtils.ToLowerCamelCase(baseMethod);
}
this.Write(name, "." + JS.Fields.PROTOTYPE + ".", baseMethod);
this.WriteCall();
this.WriteOpenParentheses();
this.WriteThis();
this.Emitter.Comma = true;
if (!isIgnore && !isIgnoreGeneric && argsInfo.HasTypeArguments)
{
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
}
needComma = false;
foreach (var arg in argsExpressions)
{
if (arg == null)
{
continue;
}
this.EnsureComma(false);
if (needComma)
{
this.WriteComma();
}
needComma = true;
arg.AcceptVisitor(this.Emitter);
}
this.Emitter.Comma = false;
this.WriteCloseParentheses();
}
else
{
var dynamicResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter) as DynamicInvocationResolveResult;
if (dynamicResolveResult != null)
{
var group = dynamicResolveResult.Target as MethodGroupResolveResult;
if (group != null && group.Methods.Count() > 1)
{
throw new EmitterException(invocationExpression, "Cannot compile this dynamic invocation because there are two or more method overloads with the same parameter count. To work around this limitation, assign the dynamic value to a non-dynamic variable before use or call a method with different parameter count");
}
}
var targetResolveResult = this.Emitter.Resolver.ResolveNode(invocationExpression.Target, this.Emitter);
var invocationResolveResult = targetResolveResult as MemberResolveResult;
IMethod method = null;
if (invocationResolveResult != null)
{
method = invocationResolveResult.Member as IMethod;
}
if (this.IsEmptyPartialInvoking(method) || IsConditionallyRemoved(invocationExpression, method))
{
this.Emitter.SkipSemiColon = true;
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
return;
}
bool isIgnore = method != null && method.DeclaringTypeDefinition != null && this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition);
bool needExpand = false;
if (method != null)
{
string paramsName = null;
var paramsParam = method.Parameters.FirstOrDefault(p => p.IsParams);
if (paramsParam != null)
{
paramsName = paramsParam.Name;
}
if (paramsName != null)
{
if (csharpInvocation != null && !csharpInvocation.IsExpandedForm)
{
needExpand = true;
}
}
}
int count = this.Emitter.Writers.Count;
invocationExpression.Target.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count > count)
{
var writer = this.Emitter.Writers.Pop();
if (method != null && method.IsExtensionMethod)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
argsInfo.ThisArgument = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
}
else if (writer.ThisArg != null)
{
argsInfo.ThisArgument = writer.ThisArg;
}
new InlineArgumentsBlock(this.Emitter, argsInfo, writer.InlineCode)
{
IgnoreRange = writer.IgnoreRange
}.Emit();
var result = this.Emitter.Output.ToString();
this.Emitter.Output = writer.Output;
this.Emitter.IsNewLine = writer.IsNewLine;
this.Write(result);
if (writer.Callback != null)
{
writer.Callback.Invoke();
}
}
else
{
if (needExpand && isIgnore)
{
this.Write("." + JS.Funcs.APPLY);
}
int openPos = this.Emitter.Output.Length;
this.WriteOpenParentheses();
bool isIgnoreGeneric = false;
var invocationResult = targetResolve as InvocationResolveResult;
if (invocationResult != null)
{
isIgnoreGeneric = Helpers.IsIgnoreGeneric(invocationResult.Member, this.Emitter);
}
if (needExpand && isIgnore)
{
StringBuilder savedBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.WriteThisExtension(invocationExpression.Target);
var thisArg = this.Emitter.Output.ToString();
this.Emitter.Output = savedBuilder;
this.Write(thisArg);
this.Emitter.Comma = true;
if (!isIgnore && !isIgnoreGeneric && argsInfo.HasTypeArguments)
{
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
}
this.EnsureComma(false);
if (argsExpressions.Length > 1)
{
this.WriteOpenBracket();
new ExpressionListBlock(this.Emitter, argsExpressions.Take(argsExpressions.Length - 1).ToArray(), paramsArg, invocationExpression, openPos).Emit();
this.WriteCloseBracket();
this.Write(".concat(");
new ExpressionListBlock(this.Emitter, new Expression[] { argsExpressions[argsExpressions.Length - 1] }, paramsArg, invocationExpression, openPos).Emit();
this.Write(")");
}
else
{
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression, -1).Emit();
}
}
else
{
this.Emitter.Comma = false;
if (!isIgnore && !isIgnoreGeneric && argsInfo.HasTypeArguments)
{
new TypeExpressionListBlock(this.Emitter, argsInfo.TypeArguments).Emit();
}
if (invocationExpression.Arguments.Count > 0)
{
this.EnsureComma(false);
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, invocationExpression, openPos).Emit();
}
this.WriteCloseParentheses();
}
}
Helpers.CheckValueTypeClone(this.Emitter.Resolver.ResolveNode(invocationExpression, this.Emitter), invocationExpression, this, pos);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = oldAsyncExpressionHandling;
}
protected virtual void EmitBaseConstructor(ConstructorDeclaration ctor, string ctorName, bool isObjectLiteral)
{
var initializer = ctor.Initializer != null && !ctor.Initializer.IsNull ? ctor.Initializer : new ConstructorInitializer()
{
ConstructorInitializerType = ConstructorInitializerType.Base
};
bool appendScope = false;
if (initializer.ConstructorInitializerType == ConstructorInitializerType.Base)
{
var baseType = this.Emitter.GetBaseTypeDefinition();
var baseName = JS.Funcs.CONSTRUCTOR;
if (ctor.Initializer != null && !ctor.Initializer.IsNull)
{
var member = ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(ctor.Initializer, this.Emitter)).Member;
var overloads = OverloadsCollection.Create(this.Emitter, member);
if (overloads.HasOverloads)
{
baseName = overloads.GetOverloadName();
}
}
string name = null;
if (this.TypeInfo.GetBaseTypes(this.Emitter).Any())
{
name = BridgeTypes.ToJsName(this.TypeInfo.GetBaseClass(this.Emitter), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
this.Write(name, ".");
this.Write(baseName);
if (!isObjectLiteral)
{
this.WriteCall();
appendScope = true;
}
}
else
{
// this.WriteThis();
string name = BridgeTypes.ToJsName(this.TypeInfo.Type, this.Emitter);
this.Write(name);
this.WriteDot();
var baseName = JS.Funcs.CONSTRUCTOR;
var member = ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(ctor.Initializer, this.Emitter)).Member;
var overloads = OverloadsCollection.Create(this.Emitter, member);
if (overloads.HasOverloads)
{
baseName = overloads.GetOverloadName();
}
this.Write(baseName);
if (!isObjectLiteral)
{
this.WriteCall();
appendScope = true;
}
}
int openPos = this.Emitter.Output.Length;
this.WriteOpenParentheses();
if (appendScope)
{
this.WriteThis();
if (initializer.Arguments.Count > 0)
{
this.WriteComma();
}
}
if (initializer.Arguments.Count > 0)
{
var argsInfo = new ArgumentsInfo(this.Emitter, ctor.Initializer);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, ctor.Initializer, openPos).Emit();
}
this.WriteCloseParentheses();
this.WriteSemiColon();
if (!isObjectLiteral)
{
this.WriteNewLine();
}
}
private void EmitExternalBaseCtor(ConstructorDeclaration ctor, ref bool requireNewLine)
{
if (ctor.Initializer != null && !ctor.Initializer.IsNull)
{
var member = ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(ctor.Initializer, this.Emitter)).Member;
var inlineCode = this.Emitter.GetInline(member);
if (!string.IsNullOrEmpty(inlineCode))
{
if (requireNewLine)
{
this.WriteNewLine();
requireNewLine = false;
}
this.Write(JS.Funcs.BRIDGE_MERGE);
this.WriteOpenParentheses();
this.Write("this, ");
var argsInfo = new ArgumentsInfo(this.Emitter, ctor.Initializer);
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineCode).Emit();
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
}
else
{
if (requireNewLine)
{
this.WriteNewLine();
requireNewLine = false;
}
var baseType = this.Emitter.GetBaseTypeDefinition();
string name = null;
if (this.TypeInfo.GetBaseTypes(this.Emitter).Any())
{
name = BridgeTypes.ToJsName(this.TypeInfo.GetBaseClass(this.Emitter), this.Emitter);
}
else
{
name = BridgeTypes.ToJsName(baseType, this.Emitter);
}
this.Write(name);
this.WriteCall();
int openPos = this.Emitter.Output.Length;
this.WriteOpenParentheses();
this.Write("this");
if (ctor.Initializer.Arguments.Count > 0)
{
this.Write(", ");
var argsInfo = new ArgumentsInfo(this.Emitter, ctor.Initializer);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, ctor.Initializer, openPos).Emit();
}
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
}
}
}
protected virtual void EmitMethods(Dictionary <string, List <MethodDeclaration> > methods, Dictionary <string, List <EntityDeclaration> > properties, Dictionary <OperatorType, List <OperatorDeclaration> > operators)
{
var names = new List <string>(properties.Keys);
foreach (var name in names)
{
var props = properties[name];
foreach (var prop in props)
{
if (prop is PropertyDeclaration)
{
this.Emitter.VisitPropertyDeclaration((PropertyDeclaration)prop);
}
else if (prop is CustomEventDeclaration)
{
this.Emitter.VisitCustomEventDeclaration((CustomEventDeclaration)prop);
}
else if (prop is IndexerDeclaration)
{
this.Emitter.VisitIndexerDeclaration((IndexerDeclaration)prop);
}
}
}
if (!this.StaticBlock)
{
MethodDeclaration entryPoint = null;
if (this.TypeInfo.StaticMethods.Any(group =>
{
return(group.Value.Any(method =>
{
var result = Helpers.IsEntryPointMethod(this.Emitter, method);
if (result)
{
entryPoint = method;
}
return result;
}));
}))
{
if (!entryPoint.Body.IsNull)
{
this.Emitter.VisitMethodDeclaration(entryPoint);
}
}
}
names = new List <string>(methods.Keys);
foreach (var name in names)
{
this.EmitMethodsGroup(methods[name]);
}
if (operators != null)
{
var ops = new List <OperatorType>(operators.Keys);
foreach (var op in ops)
{
this.EmitOperatorGroup(operators[op]);
}
}
if (this.TypeInfo.ClassType == ClassType.Struct)
{
if (!this.StaticBlock)
{
this.EmitStructMethods();
}
else
{
string structName = BridgeTypes.ToJsName(this.TypeInfo.Type, this.Emitter);
if (this.TypeInfo.Type.TypeArguments.Count > 0 &&
!Helpers.IsIgnoreGeneric(this.TypeInfo.Type, this.Emitter))
{
structName = "(" + structName + ")";
}
this.EnsureComma();
this.Write(JS.Funcs.GETDEFAULTVALUE + ": function () { return new " + structName + "(); }");
this.Emitter.Comma = true;
}
}
else if (this.StaticBlock)
{
var ctor = this.TypeInfo.Type.GetConstructors().FirstOrDefault(c => c.Parameters.Count == 0 && this.Emitter.GetInline(c) != null);
if (ctor != null)
{
var code = this.Emitter.GetInline(ctor);
this.EnsureComma();
this.Write(JS.Funcs.GETDEFAULTVALUE + ": function () ");
this.BeginBlock();
this.Write("return ");
var argsInfo = new ArgumentsInfo(this.Emitter, ctor);
new InlineArgumentsBlock(this.Emitter, argsInfo, code).Emit();
this.Write(";");
this.WriteNewLine();
this.EndBlock();
this.Emitter.Comma = true;
}
}
}
protected override void DoEmit()
{
IAttribute attribute = this.Attribute;
var type = this.Emitter.GetTypeDefinition(attribute.AttributeType);
var argsInfo = new ArgumentsInfo(this.Emitter, attribute);
string inlineCode = this.Emitter.GetInline(attribute.Constructor);
var customCtor = this.Emitter.Validator.GetCustomConstructor(type) ?? "";
var hasInitializer = attribute.NamedArguments.Count > 0;
if (inlineCode == null && Regex.Match(customCtor, @"\s*\{\s*\}\s*").Success)
{
this.WriteOpenBrace();
this.WriteSpace();
if (hasInitializer)
{
this.WriteObjectInitializer(attribute.NamedArguments, this.Emitter.AssemblyInfo.PreserveMemberCase, type, attribute);
this.WriteSpace();
}
else if (this.Emitter.Validator.IsObjectLiteral(type))
{
this.WriteObjectInitializer(null, this.Emitter.AssemblyInfo.PreserveMemberCase, type, attribute);
this.WriteSpace();
}
this.WriteCloseBrace();
}
else
{
if (hasInitializer)
{
this.Write(JS.Funcs.BRIDGE_MERGE);
this.WriteOpenParentheses();
}
if (inlineCode != null)
{
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineCode, attribute.Constructor).Emit();
}
else
{
if (String.IsNullOrEmpty(customCtor))
{
this.WriteNew();
this.Write(BridgeTypes.ToJsName(attribute.AttributeType, this.Emitter));
}
else
{
this.Write(customCtor);
}
if (!this.Emitter.Validator.IsExternalType(type) && type.Methods.Count(m => m.IsConstructor && !m.IsStatic) > (type.IsValueType ? 0 : 1))
{
this.WriteDot();
var name = OverloadsCollection.Create(this.Emitter, attribute.Constructor).GetOverloadName();
this.Write(name);
}
this.WriteOpenParentheses();
this.WritePositionalList(attribute.PositionalArguments, attribute);
this.WriteCloseParentheses();
}
if (hasInitializer)
{
this.WriteComma();
this.BeginBlock();
var inlineInit = this.WriteObjectInitializer(attribute.NamedArguments, this.Emitter.AssemblyInfo.PreserveMemberCase, type, attribute);
this.WriteNewLine();
this.EndBlock();
if (inlineInit.Count > 0)
{
this.Write(", function () ");
this.BeginBlock();
foreach (var init in inlineInit)
{
this.Write(init);
this.WriteNewLine();
}
this.EndBlock();
}
this.WriteSpace();
this.WriteCloseParentheses();
}
}
}
protected virtual void EmitInlineExpressionList(ArgumentsInfo argsInfo, string inline)
{
IEnumerable<NamedParamExpression> expressions = argsInfo.NamedExpressions;
IEnumerable<TypeParamExpression> typeParams = argsInfo.TypeArguments;
Expression paramsArg = argsInfo.ParamsExpression;
var matches = _formatArg.Matches(inline);
this.Write("");
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = this.Emitter.Writers.Count;
string key = m.Groups[2].Value;
bool isRaw = m.Groups[1].Success && m.Groups[1].Value == "*";
bool ignoreArray = isRaw || argsInfo.ParamsExpression == null;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
StringBuilder oldSb = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
if (key == "this" || key == argsInfo.ThisName || (key == "0" && argsInfo.IsExtensionMethod))
{
string thisValue = argsInfo.GetThisValue();
if (thisValue != null)
{
this.Write(thisValue);
}
}
else
{
IList<Expression> exprs = this.GetExpressionsByKey(expressions, key);
if (exprs.Count > 0)
{
if (exprs.Count > 1)
{
if (!ignoreArray)
{
this.Write("[");
}
new ExpressionListBlock(this.Emitter, exprs, null).Emit();
if (!ignoreArray)
{
this.Write("]");
}
}
else
{
string s;
if (exprs[0] != null)
{
var writer = this.SaveWriter();
this.NewWriter();
exprs[0].AcceptVisitor(this.Emitter);
s = this.Emitter.Output.ToString();
this.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
else
{
s = "null";
}
this.Write(this.WriteIndentToString(s));
}
}
else if (typeParams != null)
{
var type = this.GetAstTypeByKey(typeParams, key);
if (type != null)
{
type.AcceptVisitor(this.Emitter);
}
else
{
var iType = this.GetITypeByKey(typeParams, key);
if (iType != null)
{
new CastBlock(this.Emitter, iType).Emit();
}
}
}
}
if (this.Emitter.Writers.Count != count)
{
this.PopWriter();
}
string replacement = this.Emitter.Output.ToString();
this.Emitter.Output = oldSb;
return replacement;
});
this.Write(inline);
}
public static string GetInlineInit(Expression item, AbstractEmitterBlock block, string thisScope)
{
Expression expr = null;
if (item is NamedExpression)
{
var namedExpression = (NamedExpression)item;
expr = namedExpression.Expression;
}
else if (item is NamedArgumentExpression)
{
var namedArgumentExpression = (NamedArgumentExpression)item;
expr = namedArgumentExpression.Expression;
}
var rr = block.Emitter.Resolver.ResolveNode(item, block.Emitter);
string inlineCode = null;
if (expr != null && rr is MemberResolveResult)
{
var member = ((MemberResolveResult)rr).Member;
if (member is IProperty)
{
var setter = ((IProperty)member).Setter;
if (setter != null)
{
inlineCode = block.Emitter.GetInline(setter);
}
}
else
{
inlineCode = block.Emitter.GetInline(member);
}
if (inlineCode != null)
{
bool oldIsAssignment = block.Emitter.IsAssignment;
bool oldUnary = block.Emitter.IsUnaryAccessor;
var oldWriter = block.SaveWriter();
block.NewWriter();
block.Emitter.IsAssignment = true;
block.Emitter.IsUnaryAccessor = false;
bool hasThis = inlineCode.Contains("{this}");
if (inlineCode.StartsWith("<self>"))
{
hasThis = true;
inlineCode = inlineCode.Substring(6);
}
if (hasThis)
{
inlineCode = inlineCode.Replace("{this}", thisScope);
if (member is IProperty)
{
var argsInfo = new ArgumentsInfo(block.Emitter, item, rr);
argsInfo.ArgumentsExpressions = new Expression[] { expr };
argsInfo.ArgumentsNames = new string[] { "value" };
argsInfo.ThisArgument = thisScope;
argsInfo.NamedExpressions = argsInfo.CreateNamedExpressions(argsInfo.ArgumentsNames, argsInfo.ArgumentsExpressions);
inlineCode = inlineCode.Replace("{0}", "[[0]]");
new InlineArgumentsBlock(block.Emitter, argsInfo, inlineCode).Emit();
inlineCode = block.Emitter.Output.ToString();
inlineCode = inlineCode.Replace("[[0]]", "{0}");
}
}
else
{
if (member.SymbolKind == SymbolKind.Property)
{
var count = block.Emitter.Writers.Count;
block.PushWriter(thisScope + "." + inlineCode);
expr.AcceptVisitor(block.Emitter);
if (block.Emitter.Writers.Count > count)
{
inlineCode = block.PopWriter(true);
}
}
else
{
block.Write(thisScope + "." + inlineCode);
}
}
block.Emitter.IsAssignment = oldIsAssignment;
block.Emitter.IsUnaryAccessor = oldUnary;
block.RestoreWriter(oldWriter);
}
}
if (inlineCode != null && inlineCode.Trim().EndsWith(";"))
{
inlineCode = inlineCode.Trim().TrimEnd(';');
}
return(inlineCode);
}
protected void VisitObjectCreateExpression()
{
ObjectCreateExpression objectCreateExpression = this.ObjectCreateExpression;
var type = this.Emitter.GetTypeDefinition(objectCreateExpression.Type);
if (type.BaseType != null && type.BaseType.FullName == "System.MulticastDelegate")
{
bool wrap = false;
var parent = objectCreateExpression.Parent as InvocationExpression;
if (parent != null && parent.Target == objectCreateExpression)
{
wrap = true;
}
if (wrap)
{
this.WriteOpenParentheses();
}
objectCreateExpression.Arguments.First().AcceptVisitor(this.Emitter);
if (wrap)
{
this.WriteCloseParentheses();
}
return;
}
var argsInfo = new ArgumentsInfo(this.Emitter, objectCreateExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var argsNames = argsInfo.ArgumentsNames;
var paramsArg = argsInfo.ParamsExpression;
var argsCount = argsExpressions.Count();
var invocationResolveResult = this.Emitter.Resolver.ResolveNode(objectCreateExpression, this.Emitter) as InvocationResolveResult;
string inlineCode = null;
if (invocationResolveResult != null)
{
inlineCode = this.Emitter.GetInline(invocationResolveResult.Member);
}
var customCtor = this.Emitter.Validator.GetCustomConstructor(type) ?? "";
var hasInitializer = !objectCreateExpression.Initializer.IsNull && objectCreateExpression.Initializer.Elements.Count > 0;
bool isCollectionInitializer = false;
AstNodeCollection<Expression> elements = null;
if (hasInitializer)
{
elements = objectCreateExpression.Initializer.Elements;
isCollectionInitializer = elements.Count > 0 && elements.First() is ArrayInitializerExpression;
}
if (inlineCode == null && Regex.Match(customCtor, @"\s*\{\s*\}\s*").Success)
{
this.WriteOpenBrace();
this.WriteSpace();
if (hasInitializer)
{
this.WriteObjectInitializer(objectCreateExpression.Initializer.Elements, this.Emitter.AssemblyInfo.PreserveMemberCase, type, invocationResolveResult);
this.WriteSpace();
}
else if (this.Emitter.Validator.IsObjectLiteral(type))
{
this.WriteObjectInitializer(null, this.Emitter.AssemblyInfo.PreserveMemberCase, type, invocationResolveResult);
this.WriteSpace();
}
this.WriteCloseBrace();
}
else
{
if (hasInitializer)
{
this.Write(Bridge.Translator.Emitter.ROOT);
this.WriteDot();
this.Write(Bridge.Translator.Emitter.MERGE_OBJECT);
this.WriteOpenParentheses();
}
if (inlineCode != null)
{
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineCode).Emit();
}
else
{
if (String.IsNullOrEmpty(customCtor))
{
this.WriteNew();
objectCreateExpression.Type.AcceptVisitor(this.Emitter);
}
else
{
this.Write(customCtor);
}
this.WriteOpenParentheses();
if (!this.Emitter.Validator.IsIgnoreType(type) && type.Methods.Count(m => m.IsConstructor && !m.IsStatic) > (type.IsValueType ? 0 : 1))
{
this.WriteScript(OverloadsCollection.Create(this.Emitter, ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(objectCreateExpression, this.Emitter)).Member).GetOverloadName());
if (argsExpressions.Length > 0)
{
this.WriteComma();
}
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseParentheses();
}
if (hasInitializer)
{
this.WriteComma();
bool needComma = false;
if (isCollectionInitializer)
{
this.Write("[");
this.WriteNewLine();
this.Indent();
}
else
{
this.BeginBlock();
}
foreach (Expression item in elements)
{
if (needComma)
{
this.WriteComma();
this.WriteNewLine();
}
needComma = true;
if (item is NamedExpression)
{
var namedExpression = (NamedExpression)item;
new NameBlock(this.Emitter, namedExpression.Name, namedExpression, namedExpression.Expression).Emit();
}
else if (item is NamedArgumentExpression)
{
var namedArgumentExpression = (NamedArgumentExpression)item;
new NameBlock(this.Emitter, namedArgumentExpression.Name, namedArgumentExpression, namedArgumentExpression.Expression).Emit();
}
else if (item is ArrayInitializerExpression)
{
var arrayInitializer = (ArrayInitializerExpression)item;
this.Write("[");
foreach (var el in arrayInitializer.Elements)
{
this.EnsureComma(false);
el.AcceptVisitor(this.Emitter);
this.Emitter.Comma = true;
}
this.Write("]");
this.Emitter.Comma = false;
}
else if (item is IdentifierExpression)
{
var identifierExpression = (IdentifierExpression)item;
new IdentifierBlock(this.Emitter, identifierExpression).Emit();
}
}
this.WriteNewLine();
if (isCollectionInitializer)
{
this.Outdent();
this.Write("]");
}
else
{
this.EndBlock();
}
this.WriteSpace();
this.WriteCloseParentheses();
}
}
Helpers.CheckValueTypeClone(invocationResolveResult, this.ObjectCreateExpression, this);
}
protected void VisitObjectCreateExpression()
{
ObjectCreateExpression objectCreateExpression = this.ObjectCreateExpression;
var resolveResult = this.Emitter.Resolver.ResolveNode(objectCreateExpression.Type, this.Emitter) as TypeResolveResult;
if (resolveResult != null && resolveResult.Type.Kind == TypeKind.Enum)
{
this.Write("(0)");
return;
}
bool isTypeParam = resolveResult != null && resolveResult.Type.Kind == TypeKind.TypeParameter;
var invocationResolveResult = this.Emitter.Resolver.ResolveNode(objectCreateExpression, this.Emitter) as InvocationResolveResult;
var hasInitializer = !objectCreateExpression.Initializer.IsNull && objectCreateExpression.Initializer.Elements.Count > 0;
if (isTypeParam && invocationResolveResult != null && invocationResolveResult.Member.Parameters.Count == 0 && !hasInitializer)
{
this.Write(JS.Funcs.BRIDGE_CREATEINSTANCE);
this.WriteOpenParentheses();
this.Write(resolveResult.Type.Name);
this.WriteCloseParentheses();
return;
}
var type = isTypeParam ? null : this.Emitter.GetTypeDefinition(objectCreateExpression.Type);
var isObjectLiteral = type != null && this.Emitter.Validator.IsObjectLiteral(type);
if (type != null && type.BaseType != null && type.BaseType.FullName == "System.MulticastDelegate")
{
bool wrap = false;
var parent = objectCreateExpression.Parent as InvocationExpression;
if (parent != null && parent.Target == objectCreateExpression)
{
wrap = true;
}
if (wrap)
{
this.WriteOpenParentheses();
}
objectCreateExpression.Arguments.First().AcceptVisitor(this.Emitter);
if (wrap)
{
this.WriteCloseParentheses();
}
return;
}
var argsInfo = new ArgumentsInfo(this.Emitter, objectCreateExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
string inlineCode = null;
if (invocationResolveResult != null)
{
if (invocationResolveResult.Member.DeclaringType.Kind == TypeKind.Struct && objectCreateExpression.Arguments.Count == 0)
{
var ctors = invocationResolveResult.Member.DeclaringType.GetConstructors(c => c.Parameters.Count == 1);
var defCtor = ctors.FirstOrDefault(c => c.Parameters.First().Type.FullName == "System.Runtime.CompilerServices.DummyTypeUsedToAddAttributeToDefaultValueTypeConstructor");
if (defCtor != null)
{
inlineCode = this.Emitter.GetInline(defCtor);
}
}
if (inlineCode == null)
{
inlineCode = this.Emitter.GetInline(invocationResolveResult.Member);
}
}
var customCtor = isTypeParam ? "" : (this.Emitter.Validator.GetCustomConstructor(type) ?? "");
bool isCollectionInitializer = false;
AstNodeCollection <Expression> elements = null;
if (hasInitializer)
{
elements = objectCreateExpression.Initializer.Elements;
isCollectionInitializer = elements.Count > 0 && elements.First() is ArrayInitializerExpression;
}
var isPlainObjectCtor = Regex.Match(customCtor, @"\s*\{\s*\}\s*").Success;
var isPlainMode = type != null && this.Emitter.Validator.GetObjectCreateMode(type) == 0;
if (inlineCode == null && isPlainObjectCtor && isPlainMode)
{
this.WriteOpenBrace();
this.WriteSpace();
this.WriteObjectInitializer(objectCreateExpression.Initializer.Elements, type, invocationResolveResult, false);
this.WriteSpace();
this.WriteCloseBrace();
}
else
{
string tempVar = null;
if (hasInitializer)
{
tempVar = this.GetTempVarName();
this.WriteOpenParentheses();
this.Write(tempVar);
this.Write("=");
}
if (inlineCode != null)
{
new InlineArgumentsBlock(this.Emitter, argsInfo, inlineCode).Emit();
}
else
{
var ctorMember = ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(objectCreateExpression, this.Emitter)).Member;
var expandParams = ctorMember.Attributes.Any(a => a.AttributeType.FullName == "Bridge.ExpandParamsAttribute");
bool applyCtor = false;
if (expandParams)
{
var ctor_rr = this.Emitter.Resolver.ResolveNode(paramsArg, this.Emitter);
if (ctor_rr.Type.Kind == TypeKind.Array && !(paramsArg is ArrayCreateExpression) && objectCreateExpression.Arguments.Last() == paramsArg)
{
this.Write(JS.Types.Bridge.Reflection.APPLYCONSTRUCTOR + "(");
applyCtor = true;
}
}
if (String.IsNullOrEmpty(customCtor) || (isObjectLiteral && isPlainObjectCtor))
{
if (!applyCtor && !isObjectLiteral)
{
this.WriteNew();
}
var typerr = this.Emitter.Resolver.ResolveNode(objectCreateExpression.Type, this.Emitter).Type;
var isGeneric = typerr.TypeArguments.Count > 0 && !Helpers.IsIgnoreGeneric(typerr, this.Emitter);
if (isGeneric && !applyCtor)
{
this.WriteOpenParentheses();
}
objectCreateExpression.Type.AcceptVisitor(this.Emitter);
if (isGeneric && !applyCtor)
{
this.WriteCloseParentheses();
}
}
else
{
this.Write(customCtor);
}
if (!isTypeParam && !this.Emitter.Validator.IsExternalType(type) && type.Methods.Count(m => m.IsConstructor && !m.IsStatic) > (type.IsValueType || isObjectLiteral ? 0 : 1))
{
this.WriteDot();
var name = OverloadsCollection.Create(this.Emitter, ((InvocationResolveResult)this.Emitter.Resolver.ResolveNode(objectCreateExpression, this.Emitter)).Member).GetOverloadName();
this.Write(name);
}
if (applyCtor)
{
this.Write(", ");
}
else
{
this.WriteOpenParentheses();
}
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg, objectCreateExpression, -1).Emit();
this.WriteCloseParentheses();
}
if (hasInitializer)
{
if (isObjectLiteral && isPlainMode)
{
this.WriteObjectInitializer(objectCreateExpression.Initializer.Elements, type, invocationResolveResult, true);
}
else
{
foreach (Expression item in elements)
{
this.WriteComma();
var rr = this.Emitter.Resolver.ResolveNode(item, this.Emitter) as MemberResolveResult;
inlineCode = ObjectCreateBlock.GetInlineInit(item, this, tempVar);
if (inlineCode != null)
{
this.Write(inlineCode);
}
else if (item is NamedExpression)
{
var namedExpression = (NamedExpression)item;
this.Write(tempVar);
this.WriteDot();
this.Write(this.Emitter.GetEntityName(rr.Member));
this.Write(" = ");
namedExpression.Expression.AcceptVisitor(this.Emitter);
}
else if (item is NamedArgumentExpression)
{
var namedExpression = (NamedExpression)item;
this.Write(tempVar);
this.WriteDot();
this.Write(this.Emitter.GetEntityName(rr.Member));
this.Write(" = ");
namedExpression.Expression.AcceptVisitor(this.Emitter);
}
else if (item is ArrayInitializerExpression)
{
var arrayInitializer = (ArrayInitializerExpression)item;
this.Write("[");
foreach (var el in arrayInitializer.Elements)
{
this.EnsureComma(false);
el.AcceptVisitor(this.Emitter);
this.Emitter.Comma = true;
}
this.Write("]");
this.Emitter.Comma = false;
}
else if (item is IdentifierExpression)
{
var identifierExpression = (IdentifierExpression)item;
new IdentifierBlock(this.Emitter, identifierExpression).Emit();
}
}
}
this.WriteComma();
this.Write(tempVar);
this.WriteCloseParentheses();
}
}
//Helpers.CheckValueTypeClone(invocationResolveResult, this.ObjectCreateExpression, this, pos);
}
protected void VisitIndexerExpression()
{
IndexerExpression indexerExpression = this.IndexerExpression;
IAttribute inlineAttr = null;
string inlineCode = null;
var resolveResult = this.Emitter.Resolver.ResolveNode(indexerExpression, this.Emitter);
var memberResolveResult = resolveResult as MemberResolveResult;
var arrayAccess = resolveResult as ArrayAccessResolveResult;
if (arrayAccess != null && arrayAccess.Indexes.Count > 1)
{
this.EmitArrayAccess(indexerExpression);
return;
}
var isIgnore = true;
var isAccessorsIndexer = false;
var ignoreAccessor = false;
IProperty member = null;
IMethod method = null;
var oldIsAssignment = this.Emitter.IsAssignment;
var oldUnary = this.Emitter.IsUnaryAccessor;
if (memberResolveResult != null)
{
var resolvedMember = memberResolveResult.Member;
isIgnore = this.Emitter.Validator.IsIgnoreType(resolvedMember.DeclaringTypeDefinition);
isAccessorsIndexer =
resolvedMember.DeclaringTypeDefinition.DirectBaseTypes.Any(
t => t.FullName == "Bridge.IAccessorsIndexer");
if (resolvedMember is IProperty)
{
member = (IProperty)resolvedMember;
method = this.Emitter.IsAssignment ? member.Setter : member.Getter;
inlineAttr = this.Emitter.GetAttribute(method.Attributes, Translator.Bridge_ASSEMBLY + ".TemplateAttribute");
ignoreAccessor = this.Emitter.Validator.HasAttribute(method.Attributes, "Bridge.IgnoreAttribute");
}
}
if (inlineAttr != null)
{
var inlineArg = inlineAttr.PositionalArguments[0];
if (inlineArg.ConstantValue != null)
{
inlineCode = inlineArg.ConstantValue.ToString();
}
}
if (inlineCode != null && inlineCode.Contains("{this}"))
{
this.Write("");
var oldBuilder = this.Emitter.Output;
this.Emitter.Output = new StringBuilder();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
inlineCode = inlineCode.Replace("{this}", this.Emitter.Output.ToString());
this.Emitter.Output = oldBuilder;
this.PushWriter(inlineCode);
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
return;
}
if (inlineAttr != null || (isIgnore && !isAccessorsIndexer))
{
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
}
if (inlineAttr != null)
{
if (inlineCode != null)
{
this.WriteDot();
this.PushWriter(inlineCode);
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
new ExpressionListBlock(this.Emitter, indexerExpression.Arguments, null).Emit();
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
if (!this.Emitter.IsAssignment)
{
this.PopWriter();
}
else
{
this.WriteComma();
}
}
}
else if (!(isIgnore || ignoreAccessor) || isAccessorsIndexer)
{
string targetVar = null;
string valueVar = null;
bool writeTargetVar = false;
bool isStatement = false;
if (this.Emitter.IsAssignment && this.Emitter.AssignmentType != AssignmentOperatorType.Assign)
{
writeTargetVar = true;
}
else if (this.Emitter.IsUnaryAccessor)
{
writeTargetVar = true;
isStatement = indexerExpression.Parent is UnaryOperatorExpression && indexerExpression.Parent.Parent is ExpressionStatement;
if (memberResolveResult != null && NullableType.IsNullable(memberResolveResult.Type))
{
isStatement = false;
}
if (!isStatement)
{
this.WriteOpenParentheses();
}
}
if (writeTargetVar)
{
var targetrr = this.Emitter.Resolver.ResolveNode(indexerExpression.Target, this.Emitter);
var memberTargetrr = targetrr as MemberResolveResult;
bool isField = memberTargetrr != null && memberTargetrr.Member is IField && (memberTargetrr.TargetResult is ThisResolveResult || memberTargetrr.TargetResult is LocalResolveResult);
if (!(targetrr is ThisResolveResult || targetrr is LocalResolveResult || isField))
{
targetVar = this.GetTempVarName();
this.Write(targetVar);
this.Write(" = ");
}
}
if (this.Emitter.IsUnaryAccessor && !isStatement && targetVar == null)
{
valueVar = this.GetTempVarName();
this.Write(valueVar);
this.Write(" = ");
}
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
if (targetVar != null)
{
if (this.Emitter.IsUnaryAccessor && !isStatement)
{
this.WriteComma(false);
valueVar = this.GetTempVarName();
this.Write(valueVar);
this.Write(" = ");
this.Write(targetVar);
}
else
{
this.WriteSemiColon();
this.WriteNewLine();
this.Write(targetVar);
}
}
this.WriteDot();
var argsInfo = new ArgumentsInfo(this.Emitter, indexerExpression);
var argsExpressions = argsInfo.ArgumentsExpressions;
var paramsArg = argsInfo.ParamsExpression;
var name = Helpers.GetPropertyRef(member, this.Emitter, this.Emitter.IsAssignment);
if (!this.Emitter.IsAssignment)
{
if (this.Emitter.IsUnaryAccessor)
{
var oldWriter = this.SaveWriter();
this.NewWriter();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
var paramsStr = this.Emitter.Output.ToString();
this.RestoreWriter(oldWriter);
bool isDecimal = Helpers.IsDecimalType(member.ReturnType, this.Emitter.Resolver);
bool isNullable = NullableType.IsNullable(member.ReturnType);
if (isStatement)
{
this.Write(Helpers.GetPropertyRef(member, this.Emitter, true));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteComma(false);
if (isDecimal)
{
if (isNullable)
{
this.Write("Bridge.Nullable.lift1");
this.WriteOpenParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.WriteScript("inc");
}
else
{
this.WriteScript("dec");
}
this.WriteComma();
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write(Helpers.GetPropertyRef(member, this.Emitter, false));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteCloseParentheses();
this.WriteCloseParentheses();
}
else
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write(Helpers.GetPropertyRef(member, this.Emitter, false));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteCloseParentheses();
this.WriteDot();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("inc");
}
else
{
this.Write("dec");
}
this.WriteOpenCloseParentheses();
}
}
else
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write(Helpers.GetPropertyRef(member, this.Emitter, false));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteCloseParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("+");
}
else
{
this.Write("-");
}
this.Write("1");
}
this.WriteCloseParentheses();
}
else
{
this.Write(Helpers.GetPropertyRef(member, this.Emitter, false));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteCloseParentheses();
this.WriteComma();
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write(Helpers.GetPropertyRef(member, this.Emitter, true));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteComma(false);
if (isDecimal)
{
if (isNullable)
{
this.Write("Bridge.Nullable.lift1");
this.WriteOpenParentheses();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.WriteScript("inc");
}
else
{
this.WriteScript("dec");
}
this.WriteComma();
this.Write(valueVar);
this.WriteCloseParentheses();
}
else
{
this.Write(valueVar);
this.WriteDot();
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("inc");
}
else
{
this.Write("dec");
}
this.WriteOpenCloseParentheses();
}
}
else
{
this.Write(valueVar);
if (this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment || this.Emitter.UnaryOperatorType == UnaryOperatorType.PostIncrement)
{
this.Write("+");
}
else
{
this.Write("-");
}
this.Write("1");
}
this.WriteCloseParentheses();
this.WriteComma();
bool isPreOp = this.Emitter.UnaryOperatorType == UnaryOperatorType.Increment ||
this.Emitter.UnaryOperatorType == UnaryOperatorType.Decrement;
if (isPreOp)
{
if (targetVar != null)
{
this.Write(targetVar);
}
else
{
indexerExpression.Target.AcceptVisitor(this.Emitter);
}
this.WriteDot();
this.Write(Helpers.GetPropertyRef(member, this.Emitter, false));
this.WriteOpenParentheses();
this.Write(paramsStr);
this.WriteCloseParentheses();
}
else
{
this.Write(valueVar);
}
this.WriteCloseParentheses();
if (valueVar != null)
{
this.RemoveTempVar(valueVar);
}
}
if (targetVar != null)
{
this.RemoveTempVar(targetVar);
}
}
else
{
this.Write(name);
this.WriteOpenParentheses();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.WriteCloseParentheses();
}
}
else
{
if (this.Emitter.AssignmentType != AssignmentOperatorType.Assign)
{
var oldWriter = this.SaveWriter();
this.NewWriter();
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
var paramsStr = this.Emitter.Output.ToString();
this.RestoreWriter(oldWriter);
if (targetVar != null)
{
this.PushWriter(string.Concat(
name,
"(",
paramsStr,
", ",
targetVar,
".",
Helpers.GetPropertyRef(member, this.Emitter, false),
"(",
paramsStr,
"){0})"));
this.RemoveTempVar(targetVar);
}
else
{
oldWriter = this.SaveWriter();
this.NewWriter();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
indexerExpression.Target.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
var trg = this.Emitter.Output.ToString();
this.RestoreWriter(oldWriter);
this.PushWriter(string.Concat(
name,
"(",
paramsStr,
", ",
trg,
".",
Helpers.GetPropertyRef(member, this.Emitter, false),
"(",
paramsStr,
"){0})"));
}
}
else
{
this.Write(name);
this.WriteOpenParentheses();
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
new ExpressionListBlock(this.Emitter, argsExpressions, paramsArg).Emit();
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
this.PushWriter(", {0})");
}
}
}
else
{
if (indexerExpression.Arguments.Count != 1)
{
throw new EmitterException(indexerExpression, "Only one index is supported");
}
var index = indexerExpression.Arguments.First();
var primitive = index as PrimitiveExpression;
if (primitive != null && primitive.Value != null && Regex.Match(primitive.Value.ToString(), "^[_$a-z][_$a-z0-9]*$", RegexOptions.IgnoreCase).Success)
{
this.WriteDot();
this.Write(primitive.Value);
}
else
{
this.Emitter.IsAssignment = false;
this.Emitter.IsUnaryAccessor = false;
this.WriteOpenBracket();
index.AcceptVisitor(this.Emitter);
this.WriteCloseBracket();
this.Emitter.IsAssignment = oldIsAssignment;
this.Emitter.IsUnaryAccessor = oldUnary;
}
}
}
private void WritePart(Expression expression, bool toString, ResolveResult rr, bool isCoalescing = false)
{
if (isCoalescing)
{
ConversionBlock.expressionInWork.Add(expression);
}
if (toString)
{
var toStringMethod = rr.Type.GetMembers().FirstOrDefault(m =>
{
if (m.Name == "ToString" && !m.IsStatic && m.ReturnType.IsKnownType(KnownTypeCode.String) && m.IsOverride)
{
var method = m as IMethod;
if (method != null && method.Parameters.Count == 0 && method.TypeParameters.Count == 0)
{
return(true);
}
}
return(false);
});
if (toStringMethod != null)
{
var inline = this.Emitter.GetInline(toStringMethod);
if (inline != null)
{
var writer = new Writer
{
InlineCode = inline,
Output = this.Emitter.Output,
IsNewLine = this.Emitter.IsNewLine
};
this.Emitter.IsNewLine = false;
this.Emitter.Output = new StringBuilder();
expression.AcceptVisitor(this.Emitter);
string result = this.Emitter.Output.ToString();
this.Emitter.Output = writer.Output;
this.Emitter.IsNewLine = writer.IsNewLine;
var argsInfo = new ArgumentsInfo(this.Emitter, expression, (IMethod)toStringMethod);
argsInfo.ArgumentsExpressions = new Expression[] { expression };
argsInfo.ArgumentsNames = new string[] { "this" };
argsInfo.ThisArgument = result;
new InlineArgumentsBlock(this.Emitter, argsInfo, writer.InlineCode).Emit();
return;
}
}
expression.AcceptVisitor(this.Emitter);
}
else
{
expression.AcceptVisitor(this.Emitter);
}
if (isCoalescing)
{
ConversionBlock.expressionInWork.Remove(expression);
}
}
