protected override Statement ExpandImpl(MacroStatement macro){
if (macro.Arguments.Count == 0){
Context.Errors.Add(new CompilerError(macro.LexicalInfo,
"sub macro requires at least one reference or string attribute for subview name"));
}
var call = new MethodInvocationExpression(AstUtil.CreateReferenceExpression("OutputSubView"));
int i = 0;
foreach (Expression argument in macro.Arguments){
i++;
Expression exp = argument;
if (i == 1){
//action and contrller parameters
if (argument is ReferenceExpression && !(argument is MemberReferenceExpression)){
if (argument.ToCodeString().StartsWith("@") || argument.ToCodeString().Contains(".")){
exp = AstUtil.CreateReferenceExpression(argument.ToCodeString().Substring(1));
}
else{
exp = new StringLiteralExpression(argument.ToCodeString());
}
}
}
call.Arguments.Add(exp);
}
return new ExpressionStatement(call);
}
protected virtual void AddDependency(ArrayLiteralExpression dependencies, BinaryExpression binaryExpression)
{
StringLiteralExpression dependency;
//HACK: replace with proper AST method invocation
if (binaryExpression.Left is StringLiteralExpression)
{
dependency = new StringLiteralExpression(string.Format("{0}|{1}",
binaryExpression.Left.ToString().Trim('\''),
binaryExpression.Right.ToString().Trim('\'')));
}
else if(binaryExpression.Left is BinaryExpression)
{
var left = (BinaryExpression) binaryExpression.Left;
var package = left.Left.ToString().Trim('\'');
var version = left.Right.ToString().Trim('\'');
var dll = binaryExpression.Right.ToString().Trim('\'');
dependency = new StringLiteralExpression(string.Format("{0}|{1}|{2}",
package,
dll,
version));
}
else
throw new ArgumentOutOfRangeException(string.Format("Unknown Expression type {0} passed to RightShiftToMethodCompilerStep.AddDependency", binaryExpression.Left.GetType().Name));
dependencies.Items.Add(dependency);
}
protected override Statement ExpandImpl(MacroStatement macro){
if (macro.Arguments.Count == 0)
{
Context.Errors.Add(new CompilerError(macro.LexicalInfo,
"call macro requires at least one reference or string attribute for action name"));
}
var basis = new ReferenceExpression("Html");
var method = new MemberReferenceExpression(basis, "RenderAction");
var call = new MethodInvocationExpression(method);
int i = 0;
var result = new Block();
foreach (Expression argument in macro.Arguments){
i++;
Expression exp = argument;
if (!(exp is HashLiteralExpression)){
//action and contrller parameters
if (!(exp is NullLiteralExpression)){
exp = new StringLiteralExpression(argument.ToCodeString());
}
call.Arguments.Add(exp);
}
else{
string name = "__rd";
result.Add(
new DeclarationStatement(
new Declaration(name, null),
new MethodInvocationExpression(AstUtil.CreateReferenceExpression("RouteValueDictionary"))
)
);
var dict = argument as HashLiteralExpression;
foreach (ExpressionPair item in dict.Items){
result.Add(
new MethodInvocationExpression(
AstUtil.CreateReferenceExpression(name + ".Add"),
item.First,
item.Second
)
);
}
if (i == 2){
call.Arguments.Add(new NullLiteralExpression());
}
call.Arguments.Add(AstUtil.CreateReferenceExpression(name));
}
}
result.Add(call);
return result;
}
public void Expression_statement_is_transformed()
{
LiteralExpression exp = new StringLiteralExpression("arg1");
ExpressionStatement doStuffStatement = new ExpressionStatement(exp);
MacroStatement fixture = new MacroStatement(new LexicalInfo("test", 1, 1));
fixture.Name = "DoStuff";
fixture.Block = new Block();
fixture.Block.Add(doStuffStatement);
BlockToArgumentsTransformer transformer = new BlockToArgumentsTransformer("DoStuff");
transformer.Visit(fixture);
Assert.AreEqual(exp, fixture.Arguments[0]);
Assert.IsFalse(fixture.Block.HasStatements, "MacroStatement block should be empty after transformation.");
}
override public object Clone()
{
StringLiteralExpression clone = (StringLiteralExpression)FormatterServices.GetUninitializedObject(typeof(StringLiteralExpression));
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._entity = _entity;
if (_annotations != null)
{
clone._annotations = (Hashtable)_annotations.Clone();
}
clone._expressionType = _expressionType;
clone._value = _value;
return(clone);
}
override public object Clone()
{
StringLiteralExpression clone = new StringLiteralExpression();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null)
{
clone._annotations = (Hashtable)_annotations.Clone();
}
clone._expressionType = _expressionType;
clone._value = _value;
return(clone);
}
public void MacroStatement_with_block_is_transformed_to_MethodInvocationExpression()
{
const string methodInBlockName = "some_method";
const string doStuff = "DoStuff";
Expression argInBlockExpression = new StringLiteralExpression("argInBlock");
Statement argInBlockStatement = new ExpressionStatement(argInBlockExpression);
MacroStatement statementInBlock = GetMacroStatement(methodInBlockName, argInBlockStatement);
MacroStatement doStuffStatement = GetMacroStatement(doStuff, statementInBlock);
BlockToArgumentsTransformer transformer = new BlockToArgumentsTransformer(doStuff, methodInBlockName);
transformer.Visit(doStuffStatement);
MethodInvocationExpression mie = doStuffStatement.Arguments[0] as MethodInvocationExpression;
Assert.IsNotNull(mie, "Could not cast argument one of MacroStatement to MethodInvocationExpression.");
Assert.AreEqual(methodInBlockName, (mie.Target as ReferenceExpression).Name);
Assert.IsAssignableFrom(typeof (BlockExpression), mie.Arguments[0]);
}
private void LeaveTypeDefinition(AST.TypeDefinition node)
{
DefaultClass c = _currentClass.Pop();
foreach (AST.Attribute att in node.Attributes)
{
if (att.Name == "System.Reflection.DefaultMemberAttribute" && att.Arguments.Count == 1)
{
AST.StringLiteralExpression sle = att.Arguments[0] as AST.StringLiteralExpression;
if (sle != null)
{
foreach (DefaultProperty p in c.Properties)
{
if (p.Name == sle.Value)
{
p.IsIndexer = true;
}
}
}
}
}
//LoggingService.Debug("Leave "+node.GetType().Name+" "+node.FullName+" (Class = "+c.FullyQualifiedName+")");
}
public override Statement Expand(MacroStatement macro){
var unit = macro.GetParentNodeOfType<CompileUnit>();
var module = macro.GetParentNodeOfType<Module>();
var ns = module.Namespace.Name;
var key = new StringLiteralExpression(macro.Arguments[0].LiftToString());
var value = macro.Arguments[1];
var cls = unit.FindOrCreateClass(ns, "CommonData", null, c => c.Static());
prepareField(cls);
preparePublicProperty(cls);
getBuilderMethod(cls).Append(1, Variable.Ref(resultVar).ByIndex(key).Assign(value));
return null;
}
override public object Clone()
{
StringLiteralExpression clone = new StringLiteralExpression();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
clone._expressionType = _expressionType;
clone._value = _value;
return clone;
}
private bool BuildConfigurationChild(StringLiteralExpression child)
{
return BuildConfigurationChild(child, null, null);
}
public override void OnStringLiteralExpression(StringLiteralExpression literal)
{
_found = true;
if ((_skip = _attributesOnly) == false)
{
_applied = BuildConfigurationChild(literal);
}
}
private bool checkSubstitution(ReferenceExpression node) {
Match m = Regex.Match(node.ToCodeString(), @"^@_([\d\w]+?)(_)?$", RegexOptions.Compiled);
if (m.Success){
int idx = 0;
var isordered = int.TryParse(m.Groups[1].Value, out idx);
bool accomodate_to_strings = m.Groups[2].Value != "";
Expression exp = new NullLiteralExpression();
if (isordered){
idx = idx - 1;
if (idx < args.Count){
exp = args[idx];
}
}else{
var name = m.Groups[1].Value;
if(namedargs.ContainsKey(name)){
exp = namedargs[name];
}
}
if (accomodate_to_strings && (exp is ReferenceExpression))
{
if (exp.ToCodeString().StartsWith("@"))
{
exp = new ReferenceExpression(exp.ToCodeString().Substring(1));
}
else
{
exp = new StringLiteralExpression(exp.ToCodeString());
}
}
node.ParentNode.Replace(node, exp);
return true;
}
return false;
}
private static Expression CreateChild(StringLiteralExpression name)
{
var child = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression(typeof(ChildBuilder).FullName)
);
child.Arguments.Add(name);
return child;
}
protected Expression string_literal() //throws RecognitionException, TokenStreamException
{
Expression e;
IToken dqs = null;
IToken sqs = null;
IToken tqs = null;
IToken bqs = null;
e = null;
try { // for error handling
switch ( LA(1) )
{
case ESEPARATOR:
{
e=expression_interpolation();
break;
}
case DOUBLE_QUOTED_STRING:
{
dqs = LT(1);
match(DOUBLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(ToLexicalInfo(dqs), dqs.getText());
e.Annotate("quote", "\"");
}
break;
}
case SINGLE_QUOTED_STRING:
{
sqs = LT(1);
match(SINGLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(ToLexicalInfo(sqs), sqs.getText());
e.Annotate("quote", "'");
}
break;
}
case TRIPLE_QUOTED_STRING:
{
tqs = LT(1);
match(TRIPLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(ToLexicalInfo(tqs), tqs.getText());
e.Annotate("quote", "\"\"\"");
}
break;
}
case BACKTICK_QUOTED_STRING:
{
bqs = LT(1);
match(BACKTICK_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(ToLexicalInfo(bqs), bqs.getText());
e.Annotate("quote", "`");
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "string_literal");
recover(ex,tokenSet_44_);
}
else
{
throw ex;
}
}
return e;
}
public static Expression exclude(BlockExpression action)
{
var arrayExpression = new ArrayLiteralExpression();
foreach (Statement statement in action.Body.Statements)
{
var stringLiteral =
new StringLiteralExpression(
((MethodInvocationExpression) (((ExpressionStatement) (statement)).Expression)).Arguments[0].ToString().Trim(new[]{'\''}));
arrayExpression.Items.Add(stringLiteral);
}
return new MethodInvocationExpression(
new ReferenceExpression("SetExcludeList"),
arrayExpression
);
}
//throws RecognitionException, TokenStreamException
protected Expression string_literal()
{
Expression e;
IToken dqs = null;
IToken sqs = null;
IToken tqs = null;
e = null;
try { // for error handling
switch ( LA(1) )
{
case ESEPARATOR:
{
e=expression_interpolation();
break;
}
case DOUBLE_QUOTED_STRING:
{
dqs = LT(1);
match(DOUBLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(SourceLocationFactory.ToLexicalInfo(dqs), dqs.getText());
}
break;
}
case SINGLE_QUOTED_STRING:
{
sqs = LT(1);
match(SINGLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(SourceLocationFactory.ToLexicalInfo(sqs), sqs.getText());
}
break;
}
case TRIPLE_QUOTED_STRING:
{
tqs = LT(1);
match(TRIPLE_QUOTED_STRING);
if (0==inputState.guessing)
{
e = new StringLiteralExpression(SourceLocationFactory.ToLexicalInfo(tqs), tqs.getText());
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_36_);
}
else
{
throw ex;
}
}
return e;
}
public override void OnStringLiteralExpression(StringLiteralExpression node)
{
if (null == node.Value)
{
_il.Emit(OpCodes.Ldnull);
}
else if (0 != node.Value.Length)
{
_il.Emit(OpCodes.Ldstr, node.Value);
}
else /* force use of CLR-friendly string.Empty */
{
_il.Emit(OpCodes.Ldsfld, typeof(string).GetField("Empty"));
}
PushType(TypeSystemServices.StringType);
}
public Expression string_literal()
{
Expression expression = null;
IToken token = null;
IToken token2 = null;
try
{
IToken token3;
switch (this.LA(1))
{
case 60:
token = this.LT(1);
this.match(60);
if (base.inputState.guessing == 0)
{
token3 = token;
}
break;
case 0x6d:
token2 = this.LT(1);
this.match(0x6d);
if (base.inputState.guessing == 0)
{
token3 = token2;
}
break;
default:
throw new NoViableAltException(this.LT(1), this.getFilename());
}
if (base.inputState.guessing == 0)
{
expression = new StringLiteralExpression(ToLexicalInfo(token3), token3.getText());
}
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_20_);
return expression;
}
return expression;
}
override public void OnStringLiteralExpression(StringLiteralExpression node)
{
Write("StringLiteralExpression(");
BooPrinterVisitor.WriteStringLiteral(node.Value, _writer);
Write(")");
}
public override void OnStringLiteralExpression(StringLiteralExpression e)
{
WriteStringLiteral(e.Value);
}
public static Expression install(ReferenceExpression expression,
BlockExpression action)
{
var installName = new StringLiteralExpression(expression.Name);
return new MethodInvocationExpression(
new ReferenceExpression("GetInstallerMeta"),
installName,
action
);
}
private static Expression joinInterpolations(ExpressionInterpolationExpression expressionInterpolationExpression) {
var srcexpressions = expressionInterpolationExpression.Expressions.ToList();
ExpressionInterpolationExpression result = new ExpressionInterpolationExpression();
StringLiteralExpression current = null;
foreach (var srcexpression in srcexpressions) {
if(srcexpression is LiteralExpression) {
var str = new StringLiteralExpression(((LiteralExpression) srcexpression).ValueObject.toStr());
if(null==current) {
current = str;
}else {
current.Value += str.Value;
}
}else {
if(current!=null) {
result.Expressions.Add(current);
current = null;
}
result.Expressions.Add(srcexpression);
}
}
if (current != null)
{
result.Expressions.Add(current);
}
if(result.Expressions.Count>1) return result;
return result.Expressions[0];
}
public static Expression mode(ReferenceExpression expression, BlockExpression action)
{
var modename = new StringLiteralExpression(expression.Name);
return new MethodInvocationExpression(
new ReferenceExpression("ApplyModeSettings"),
modename,
action
);
}
public override void OnStringLiteralExpression(StringLiteralExpression node)
{
MakeResult(projectContent.SystemTypes.String);
}
public override Statement Expand(MacroStatement macro)
{
componentContextName = ComponentNaming.GetComponentContextName(macro);
componentFactoryName = ComponentNaming.GetComponentFactoryName(macro);
componentVariableName = ComponentNaming.GetComponentNameFor(macro);
if (macro.Arguments.Count == 0) throw new MonoRailException("Component must be called with a name");
var block = new Block();
var method = (Method) macro.GetAncestor(NodeType.Method);
var componentName = new StringLiteralExpression(macro.Arguments[0].ToString());
var dictionary = CreateParametersDictionary(macro);
var macroBody = CodeBuilderHelper.CreateCallableFromMacroBody(CodeBuilder, macro);
var initContext = new MethodInvocationExpression
{
Target = AstUtil.CreateReferenceExpression("Castle.MonoRail.Views.Brail.BrailViewComponentContext")
};
initContext.Arguments.Extend(
new[]
{
new SelfLiteralExpression(),
macroBody, componentName,
AstUtil.CreateReferenceExpression("OutputStream"),
dictionary
});
// compilerContext = BrailViewComponentContext(macroBodyClosure, "componentName", OutputStream, dictionary)
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
new ReferenceExpression(componentContextName), initContext));
// AddViewComponentProperties( compilerContext.ComponentParams )
var addProperties =
new MethodInvocationExpression(AstUtil.CreateReferenceExpression("AddViewComponentProperties"));
addProperties.Arguments.Add(AstUtil.CreateReferenceExpression(componentContextName + ".ComponentParameters"));
block.Add(addProperties);
var viewComponentFactoryLocal = CodeBuilder.DeclareLocal(method, componentFactoryName,
TypeSystemServices.Map(
typeof(IViewComponentFactory)));
// viewComponentFactory = context.GetService(IViewComponentFactory)
var callService = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("context.GetService"));
callService.Arguments.Add(CodeBuilder.CreateTypeofExpression(typeof(IViewComponentFactory)));
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
CodeBuilder.CreateLocalReference(componentFactoryName, viewComponentFactoryLocal),
callService));
// component = viewComponentFactory.Create( componentName)
var createComponent = new MethodInvocationExpression(
new MemberReferenceExpression(CodeBuilder.CreateLocalReference(componentFactoryName, viewComponentFactoryLocal),
"Create"));
createComponent.Arguments.Add(componentName);
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
new ReferenceExpression(componentVariableName),
createComponent));
AddSections(block, macro);
// component.Init(context, componentContext)
var initComponent = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression(componentVariableName + ".Init"));
initComponent.Arguments.Extend(
new Expression[]
{
new ReferenceExpression("context"),
new ReferenceExpression(componentContextName)
});
block.Add(initComponent);
// component.Render()
block.Add(new MethodInvocationExpression(
AstUtil.CreateReferenceExpression(componentVariableName + ".Render")));
// if component.ViewToRender is not null:
// OutputSubView("/"+component.ViewToRender, context.CompnentParameters)
var renderView = new Block();
var outputSubView = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("OutputSubView"));
outputSubView.Arguments.Add(new BinaryExpression(BinaryOperatorType.Addition,
new StringLiteralExpression("/"),
AstUtil.CreateReferenceExpression(componentContextName +
".ViewToRender")));
outputSubView.Arguments.Add(AstUtil.CreateReferenceExpression(componentContextName + ".ComponentParameters"));
renderView.Add(outputSubView);
block.Add(new IfStatement(AstUtil.CreateReferenceExpression(componentContextName + ".ViewToRender"),
renderView, new Block()));
// RemoveViewComponentProperties( compilerContext.ComponentParams )
var removeProperties =
new MethodInvocationExpression(AstUtil.CreateReferenceExpression("RemoveViewComponentProperties"));
removeProperties.Arguments.Add(AstUtil.CreateReferenceExpression(componentContextName + ".ComponentParameters"));
block.Add(removeProperties);
return block;
}
public override void OnStringLiteralExpression(StringLiteralExpression node)
{
_expression = new CodePrimitiveExpression(node.Value);
}
public override Statement Expand(MacroStatement macro)
{
if (macro.Arguments.Count == 0)
throw new RailsException("Component must be called with a name");
Block block = new Block();
Method method;
Node parent = macro.ParentNode;
while((parent is Method) == false)
{
parent = parent.ParentNode;
}
method = (Method) parent;
StringLiteralExpression componentName = new StringLiteralExpression(macro.Arguments[0].ToString());
MethodInvocationExpression dictionary = CreateParametersDictionary(macro);
Expression macroBody = CodeBuilderHelper.CreateCallableFromMacroBody(CodeBuilder, macro);
MethodInvocationExpression initContext = new MethodInvocationExpression();
initContext.Target = AstUtil.CreateReferenceExpression("Castle.MonoRail.Views.Brail.BrailViewComponentContext");
initContext.Arguments.Extend(
new Expression[]
{
new SelfLiteralExpression(),
macroBody, componentName,
AstUtil.CreateReferenceExpression("OutputStream"),
dictionary
});
// compilerContext = BrailViewComponentContext(macroBodyClosure, "componentName", OutputStream, dictionary)
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
new ReferenceExpression("componentContext"), initContext));
// AddViewComponentProperties( compilerContext.ComponentParams )
MethodInvocationExpression addProperties = new MethodInvocationExpression(AstUtil.CreateReferenceExpression("AddViewComponentProperties"));
addProperties.Arguments.Add(AstUtil.CreateReferenceExpression("componentContext.ComponentParameters"));
block.Add(addProperties);
InternalLocal viewComponentFactoryLocal = CodeBuilder.DeclareLocal(method, "viewComponentFactory",
TypeSystemServices.Map(
typeof(IViewComponentFactory)));
// viewComponentFactory = MonoRailHttpHandler.CurrentContext.GetService(IViewComponentFactory)
MethodInvocationExpression callService = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("MonoRailHttpHandler.CurrentContext.GetService"));
callService.Arguments.Add(CodeBuilder.CreateTypeofExpression(typeof(IViewComponentFactory)));
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
CodeBuilder.CreateLocalReference("viewComponentFactory", viewComponentFactoryLocal),
callService));
// component = viewComponentFactory.Create( componentName)
MethodInvocationExpression createComponent = new MethodInvocationExpression(
new MemberReferenceExpression(CodeBuilder.CreateLocalReference("viewComponentFactory", viewComponentFactoryLocal),
"Create"));
createComponent.Arguments.Add(componentName);
block.Add(new BinaryExpression(BinaryOperatorType.Assign,
new ReferenceExpression("component"),
createComponent));
AddSections(block, macro);
// component.Init(context, componentContext)
MethodInvocationExpression initComponent = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("component.Init"));
initComponent.Arguments.Extend(
new Expression[] {AstUtil.CreateReferenceExpression("context"), new ReferenceExpression("componentContext")});
block.Add(initComponent);
// component.Render()
block.Add(new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("component.Render")));
// if component.ViewToRender is not null:
// OutputSubView("/"+component.ViewToRender, context.CompnentParameters)
Block renderView = new Block();
MethodInvocationExpression outputSubView = new MethodInvocationExpression(
AstUtil.CreateReferenceExpression("OutputSubView"));
outputSubView.Arguments.Add(new BinaryExpression(BinaryOperatorType.Addition,
new StringLiteralExpression("/"),
AstUtil.CreateReferenceExpression("componentContext.ViewToRender")));
outputSubView.Arguments.Add(AstUtil.CreateReferenceExpression("componentContext.ComponentParameters"));
renderView.Add(outputSubView);
block.Add(new IfStatement(AstUtil.CreateReferenceExpression("componentContext.ViewToRender"),
renderView, new Block()));
// RemoveViewComponentProperties( compilerContext.ComponentParams )
MethodInvocationExpression removeProperties = new MethodInvocationExpression(AstUtil.CreateReferenceExpression("RemoveViewComponentProperties"));
removeProperties.Arguments.Add(AstUtil.CreateReferenceExpression("componentContext.ComponentParameters"));
block.Add(removeProperties);
return block;
}
public override void OnStringLiteralExpression(StringLiteralExpression literal)
{
literal.Value = _name = NormalizeName(literal.Value);
_node = !_isAttribute ? literal : CreateAttribute(_name);
}
public override void OnMemberReferenceExpression(MemberReferenceExpression node)
{
ReferenceExpression reference = node.Target as ReferenceExpression;
if (reference != null && reference.Name.StartsWith("@"))
{
_component = reference;
}
else
{
_component = AstUtil.CreateMethodInvocationExpression(
AstUtil.CreateReferenceExpression(typeof(ComponentReference).FullName),
node.Target
);
}
_method = new StringLiteralExpression(node.Name);
_found = true;
}
public override void OnStringLiteralExpression(StringLiteralExpression node)
{
ReplaceWithCallToExpressionConstant(node);
}
public override void OnStringLiteralExpression(StringLiteralExpression node)
{
BindExpressionType(node, TypeSystemServices.StringType);
}
public StringLiteralExpression CreateStringLiteral(string value)
{
StringLiteralExpression expression = new StringLiteralExpression(value);
expression.ExpressionType = _tss.StringType;
return expression;
}