public ExpressionTreeBuilder(ICompilation compilation, IEmitter emitter, SyntaxTree syntaxTree, AbstractEmitterBlock block)
{
_compilation = compilation;
_emitter = emitter;
_syntaxTree = syntaxTree;
_expression = (ITypeDefinition)ReflectionHelper.ParseReflectionName(typeof(Expression).FullName).Resolve(compilation);
_allParameters = new Dictionary <IVariable, string>();
_block = block;
}
public virtual void WriteIndented(string s, int?position = null)
{
var level = position.HasValue && position.Value == 0 ? InitialLevel : Level;
var indented = new StringBuilder(AbstractEmitterBlock.WriteIndentToString(s, level));
WriteIndent(indented, level, 0);
Write(Output, indented.ToString(), position);
}
protected virtual void WrapToModules()
{
using (var m = new Measure(Logger, "Wrapping to modules", logLevel: LogLevel.Trace))
{
foreach (var outputPair in Outputs)
{
CancellationToken.ThrowIfCancellationRequested();
var output = outputPair.Value;
int k = 0;
foreach (var moduleOutputPair in output.ModuleOutput)
{
var module = moduleOutputPair.Key;
var moduleOutput = moduleOutputPair.Value;
m.SetOperations(++k).EmitPartial($"Processing Module '{module.Name}");
AbstractEmitterBlock.RemovePenultimateEmptyLines(moduleOutput, true);
switch (module.Type)
{
case ModuleType.CommonJS:
WrapToCommonJS(moduleOutput, module, output);
break;
case ModuleType.UMD:
WrapToUMD(moduleOutput, module, output);
break;
case ModuleType.ES6:
WrapToES6(moduleOutput, module, output);
break;
case ModuleType.AMD:
default:
WrapToAMD(moduleOutput, module, output);
break;
}
}
}
}
}
public static string GetInlineInit(KeyValuePair <IMember, ResolveResult> item, AbstractEmitterBlock block)
{
string inlineCode = null;
var member = item.Key;
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 = Helpers.HasThis(inlineCode);
inlineCode = Helpers.ConvertTokens(block.Emitter, inlineCode, member);
if (inlineCode.StartsWith("<self>"))
{
hasThis = true;
inlineCode = inlineCode.Substring(6);
}
if (hasThis)
{
inlineCode = inlineCode.Replace("{this}", "this");
if (member is IProperty)
{
inlineCode = inlineCode.Replace("{0}", "[[0]]");
WriteResolveResult(item.Value, block);
var value = block.Emitter.Output.ToString();
inlineCode = inlineCode.Replace("{value}", value);
inlineCode = inlineCode.Replace("[[0]]", "{0}");
}
}
else
{
if (member.SymbolKind == SymbolKind.Property)
{
var count = block.Emitter.Writers.Count;
block.PushWriter("this." + inlineCode);
WriteResolveResult(item.Value, block);
if (block.Emitter.Writers.Count > count)
{
inlineCode = block.PopWriter(true);
}
}
else
{
block.Write("this." + inlineCode);
}
}
block.Emitter.IsAssignment = oldIsAssignment;
block.Emitter.IsUnaryAccessor = oldUnary;
block.RestoreWriter(oldWriter);
}
if (inlineCode != null && !inlineCode.Trim().EndsWith(";"))
{
inlineCode += ";";
}
return(inlineCode);
}
public static void WriteResolveResult(ResolveResult rr, AbstractEmitterBlock block)
{
if (rr is ConversionResolveResult)
{
rr = ((ConversionResolveResult)rr).Input;
}
if (rr is TypeOfResolveResult)
{
block.Write(H5Types.ToJsName(((TypeOfResolveResult)rr).ReferencedType, block.Emitter));
}
else if (rr is ArrayCreateResolveResult)
{
TypeSystemAstBuilder typeBuilder =
new TypeSystemAstBuilder(new CSharpResolver(block.Emitter.Resolver.Compilation));
var expression = typeBuilder.ConvertConstantValue(rr) as ArrayCreateExpression;
new ArrayCreateBlock(block.Emitter, expression, (ArrayCreateResolveResult)rr).Emit();
}
else if (rr is MemberResolveResult mrr)
{
if (mrr.IsCompileTimeConstant && mrr.Member.DeclaringType.Kind == TypeKind.Enum)
{
if (mrr.Member.DeclaringType is DefaultResolvedTypeDefinition typeDef)
{
var enumMode = Helpers.EnumEmitMode(typeDef);
if ((block.Emitter.Validator.IsExternalType(typeDef) && enumMode == -1) || enumMode == 2)
{
block.WriteScript(mrr.ConstantValue);
return;
}
if (enumMode >= 3 && enumMode < 7)
{
string enumStringName = mrr.Member.Name;
var attr = Helpers.GetInheritedAttribute(mrr.Member,
Translator.H5_ASSEMBLY + ".NameAttribute");
if (attr != null)
{
enumStringName = block.Emitter.GetEntityName(mrr.Member);
}
else
{
switch (enumMode)
{
case 3:
enumStringName =
Object.Net.Utilities.StringUtils.ToLowerCamelCase(mrr.Member.Name);
break;
case 4:
break;
case 5:
enumStringName = enumStringName.ToLowerInvariant();
break;
case 6:
enumStringName = enumStringName.ToUpperInvariant();
break;
}
}
block.WriteScript(enumStringName);
}
else
{
block.WriteScript(rr.ConstantValue);
}
}
}
else
{
block.WriteScript(rr.ConstantValue);
}
}
else
{
block.WriteScript(rr.ConstantValue);
}
}
public override string VisitThisResolveResult(ThisResolveResult rr, object data)
{
return(CompileFactoryCall("Constant", new[] { typeof(object), typeof(Type) }, new[] { AbstractEmitterBlock.GetThisAlias(_emitter), GetTypeName(rr.Type, _emitter) }));
}
private string MakeConstant(ResolveResult rr)
{
var value = rr.ConstantValue == null?DefaultValueBlock.DefaultValue(rr, _emitter) : AbstractEmitterBlock.ToJavaScript(rr.ConstantValue, _emitter);
return(CompileFactoryCall("Constant", new[] { typeof(object), typeof(Type) }, new[] { value, GetTypeName(rr.Type, _emitter) }));
}
public static string GetInlineInit(Expression item, AbstractEmitterBlock block, string thisScope)
{
Expression expr = null;
if (item is NamedExpression namedExpression)
{
expr = namedExpression.Expression;
}
else if (item is NamedArgumentExpression namedArgumentExpression)
{
expr = namedArgumentExpression.Expression;
}
var rr = block.Emitter.Resolver.ResolveNode(item);
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;
inlineCode = Helpers.ConvertTokens(block.Emitter, inlineCode, member);
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);
}
