private bool IsExposedExpression(Expression expression)
{
if (expression.NodeType == NodeType.Literal)
{
Literal literal = (Literal)expression;
TypeNode type = literal.Type;
if (!IsExposedType(type))
{
return(false);
}
if (type.FullName == "System.Type")
{
// if the value is itself a type, we need to test whether that type is visible
TypeNode value = literal.Value as TypeNode;
if ((value != null) && !IsExposedType(value))
{
return(false);
}
}
return(true);
}
else if (expression.NodeType == NodeType.NamedArgument)
{
NamedArgument assignment = (NamedArgument)expression;
return(IsExposedExpression(assignment.Value));
}
else
{
throw new InvalidOperationException("Encountered unrecognized expression");
}
}
public static Literal GetNamedAttributeValue(AttributeNode attr, Identifier name)
{
if (attr == null)
{
return(null);
}
ExpressionList exprs = attr.Expressions;
if (exprs == null)
{
return(null);
}
for (int i = 0, n = exprs.Count; i < n; i++)
{
NamedArgument na = exprs[i] as NamedArgument;
if (na == null)
{
continue;
}
if (na.Name.UniqueIdKey == name.UniqueIdKey)
{
return(na.Value as Literal);
}
}
return(null);
}
public bool TryGetArg(int index, out NamedArgument arg)
{
if (index < 0 || index >= count)
{
arg = default(NamedArgument);
return(false);
}
if (args != null)
{
arg = args[index];
}
else
{
switch (index)
{
case 0:
arg = arg1;
break;
case 1:
arg = arg2;
break;
case 2:
arg = arg3;
break;
default:
arg = arg4;
break;
}
}
return(true);
}
public void Add(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4)
{
Add(arg1);
Add(arg2);
Add(arg3);
Add(arg4);
}
public static bool Formatted(ref TaggedString __result, string str, NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4, NamedArgument arg5, NamedArgument arg6, NamedArgument arg7, NamedArgument arg8)
{
List <string> argsLabels = getArgsLabels();
List <object> argsObjects = getArgsObjects();
argsLabels.Clear();
argsObjects.Clear();
argsLabels.Add(arg1.label);
argsObjects.Add(arg1.arg);
argsLabels.Add(arg2.label);
argsObjects.Add(arg2.arg);
argsLabels.Add(arg3.label);
argsObjects.Add(arg3.arg);
argsLabels.Add(arg4.label);
argsObjects.Add(arg4.arg);
argsLabels.Add(arg5.label);
argsObjects.Add(arg5.arg);
argsLabels.Add(arg6.label);
argsObjects.Add(arg6.arg);
argsLabels.Add(arg7.label);
argsObjects.Add(arg7.arg);
argsLabels.Add(arg8.label);
argsObjects.Add(arg8.arg);
__result = GrammarResolverSimple.Formatted(str, argsLabels, argsObjects);
return(false);
}
// Token: 0x0600007C RID: 124 RVA: 0x000067F8 File Offset: 0x000049F8
public static void RemoveTrait(Pawn pawn, Trait trait, string doer, MessageTypeDef MsgType, bool SendMsg = true)
{
Pawn_StoryTracker story = pawn.story;
Trait remTrait = (story != null) ? (from x in story.traits.allTraits
where x.def == trait.def
select x).FirstOrDefault() : null;
if (remTrait == null)
{
return;
}
if (pawn != null)
{
Pawn_StoryTracker story2 = pawn.story;
if (story2 != null)
{
story2.traits.allTraits.Remove(remTrait);
}
}
MSTraitChanger.TraitsUpdated(pawn);
if (SendMsg)
{
string key = "MSExotic.TraitRemoved";
NamedArgument arg = pawn?.LabelShort.CapitalizeFirst();
Trait trait2 = trait;
Messages.Message(key.Translate(arg, trait2?.Label.CapitalizeFirst(), doer.CapitalizeFirst()), pawn, MsgType, true);
}
}
private CustomAttribute HandleCustomAttribute(Cts.MethodDesc constructor, Ecma.CustomAttributeValue <Cts.TypeDesc> decodedValue)
{
CustomAttribute result = new CustomAttribute
{
Constructor = HandleQualifiedMethod(constructor),
};
result.FixedArguments.Capacity = decodedValue.FixedArguments.Length;
foreach (var decodedArgument in decodedValue.FixedArguments)
{
var fixedArgument = HandleCustomAttributeConstantValue(decodedArgument.Type, decodedArgument.Value);
result.FixedArguments.Add(fixedArgument);
}
result.NamedArguments.Capacity = decodedValue.NamedArguments.Length;
foreach (var decodedArgument in decodedValue.NamedArguments)
{
var namedArgument = new NamedArgument
{
Flags = decodedArgument.Kind == Ecma.CustomAttributeNamedArgumentKind.Field ?
NamedArgumentMemberKind.Field : NamedArgumentMemberKind.Property,
Name = HandleString(decodedArgument.Name),
Type = HandleType(decodedArgument.Type),
Value = HandleCustomAttributeConstantValue(decodedArgument.Type, decodedArgument.Value)
};
result.NamedArguments.Add(namedArgument);
}
return(result);
}
// Token: 0x0600007C RID: 124 RVA: 0x000067F8 File Offset: 0x000049F8
public static void RemoveTrait(Pawn pawn, Trait trait, string doer, MessageTypeDef MsgType, bool SendMsg = true)
{
var story = pawn.story;
var remTrait = story != null
? (from x in story.traits.allTraits
where x.def == trait.def
select x).FirstOrDefault()
: null;
if (remTrait == null)
{
return;
}
var story2 = pawn.story;
story2?.traits.allTraits.Remove(remTrait);
TraitsUpdated(pawn);
if (!SendMsg)
{
return;
}
var key = "MSExotic.TraitRemoved";
NamedArgument arg = pawn.LabelShort.CapitalizeFirst();
var trait2 = trait;
Messages.Message(key.Translate(arg, trait2?.Label.CapitalizeFirst(), doer.CapitalizeFirst()), pawn,
MsgType);
}
//
// If throwIfMissingMetadata is false, returns null rather than throwing a MissingMetadataException.
//
internal sealed override IList <CustomAttributeNamedArgument> GetNamedArguments(bool throwIfMissingMetadata)
{
LowLevelListWithIList <CustomAttributeNamedArgument> customAttributeNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>();
foreach (NamedArgumentHandle namedArgumentHandle in _customAttribute.NamedArguments)
{
NamedArgument namedArgument = namedArgumentHandle.GetNamedArgument(_reader);
String memberName = namedArgument.Name.GetString(_reader);
bool isField = (namedArgument.Flags == NamedArgumentMemberKind.Field);
CustomAttributeTypedArgument typedValue =
ParseFixedArgument(
_reader,
namedArgument.Value,
throwIfMissingMetadata,
delegate()
{
// We got here because the custom attribute blob did not inclue type information. For named arguments, this is considered illegal metadata
// (ECMA always includes type info for named arguments.)
throw new BadImageFormatException();
}
);
if (typedValue.ArgumentType == null)
{
Debug.Assert(!throwIfMissingMetadata);
return(null);
}
customAttributeNamedArguments.Add(ReflectionAugments.CreateCustomAttributeNamedArgument(this.AttributeType, memberName, isField, typedValue));
}
return(customAttributeNamedArguments);
}
When_formatting_command_line_with_Single_style_Then_it_should_return_single_string_with_Name_and_Value_delimited_by_equals_sign()
{
var sut = new NamedArgument("ArgumentName", "ArgumentValue");
IEnumerable <string> commandLine = sut.FormatCommandLine("---", CommandLineArgumentStyle.SingleWithEqualsSignDelimiter);
commandLine.Should().Equal("---ArgumentName=ArgumentValue");
}
When_formatting_command_line_with_Separated_style_Then_it_should_return_Name_and_Value_strings()
{
var sut = new NamedArgument("ArgumentName", "ArgumentValue");
IEnumerable <string> commandLine = sut.FormatCommandLine("---", CommandLineArgumentStyle.Separated);
commandLine.Should().Equal("---ArgumentName", "ArgumentValue");
}
public SignalArgs(SignalArgs args)
{
count = args.count;
arg1 = args.arg1;
arg2 = args.arg2;
arg3 = args.arg3;
arg4 = args.arg4;
this.args = args.args;
}
public SignalArgs(NamedArgument arg1)
{
count = 1;
this.arg1 = arg1;
arg2 = default(NamedArgument);
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
args = null;
}
public SignalArgs(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3)
{
count = 3;
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
arg4 = default(NamedArgument);
args = null;
}
public static JToken ToJson(NamedArgument arg)
{
var obj = (JObject)ToJson((SyntaxNode)arg);
obj["type"] = "NamedArgument";
obj["name"] = ToJson(arg.Name);
obj["value"] = ToJson((dynamic)arg.Value);
return(obj);
}
public static JToken ToJson(NamedArgument arg)
{
return(new JObject
{
{ "type", "narg" },
{ "name", arg.Name },
{ "val", ToJson(arg.Value) }
});
}
public SignalArgs(NamedArgument arg1, NamedArgument arg2, NamedArgument arg3, NamedArgument arg4)
{
count = 4;
this.arg1 = arg1;
this.arg2 = arg2;
this.arg3 = arg3;
this.arg4 = arg4;
args = null;
}
public void ComposesArgumentsForRequiredNamedArguments()
{
NamedArgument <string> namedArgument = this.AddNamedArgument("name", "placeholder", null, Optional <IEnumerable <string> > .CreateNotSet());
this.requiredArguments.Add(namedArgument);
Usage result = this.testee.Compose();
result.Arguments.Should().Be("-name <placeholder>");
}
public void ComposesOptionsForNamedArguments_WithAlias()
{
NamedArgument <string> namedArgument = this.AddNamedArgument("name", "placeholder", "description", Optional <IEnumerable <string> > .CreateNotSet());
this.longAliases.Add("alias", namedArgument);
this.longAliases.Add("other_alias", namedArgument);
Usage result = this.testee.Compose();
result.Options.Should().Be(Lines("-name <placeholder> (--alias, --other_alias)\tdescription"));
}
public SignalArgs(params NamedArgument[] args)
{
count = args.Length;
if (args.Length > 4)
{
arg1 = default(NamedArgument);
arg2 = default(NamedArgument);
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
this.args = new NamedArgument[args.Length];
for (int i = 0; i < args.Length; i++)
{
this.args[i] = args[i];
}
return;
}
if (args.Length == 1)
{
arg1 = args[0];
arg2 = default(NamedArgument);
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
}
else if (args.Length == 2)
{
arg1 = args[0];
arg2 = args[1];
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
}
else if (args.Length == 3)
{
arg1 = args[0];
arg2 = args[1];
arg3 = args[2];
arg4 = default(NamedArgument);
}
else if (args.Length == 4)
{
arg1 = args[0];
arg2 = args[1];
arg3 = args[2];
arg4 = args[3];
}
else
{
arg1 = default(NamedArgument);
arg2 = default(NamedArgument);
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
}
this.args = null;
}
/// <summary>
/// Determines if position is in the argument name. Typically used to
/// a) suppress general intellisense when typing function arguments
/// in a function/ definition such as in 'x <- function(a|'
/// b) determine if completion list should contain argumet names
/// when user types inside function call.
/// </summary>
internal static bool IsInFunctionArgumentName <T>(AstRoot ast, int position) where T : class, IFunction
{
T funcDef = ast.GetNodeOfTypeFromPosition <T>(position);
if (funcDef == null || funcDef.OpenBrace == null || funcDef.Arguments == null)
{
return(false);
}
if (position < funcDef.OpenBrace.End || position >= funcDef.SignatureEnd)
{
return(false);
}
int start = funcDef.OpenBrace.End;
int end = funcDef.SignatureEnd;
if (funcDef.Arguments.Count == 0 && position >= start && position <= end)
{
return(true);
}
for (int i = 0; i < funcDef.Arguments.Count; i++)
{
CommaSeparatedItem csi = funcDef.Arguments[i];
NamedArgument na = csi as NamedArgument;
if (position < csi.Start)
{
break;
}
end = csi.End;
if (position >= start && position <= end)
{
if (na == null)
{
return(true);
}
if (position <= na.EqualsSign.Start)
{
return(true);
}
}
}
return(false);
}
public void Succeeds_WhenRequiredNamedArgumentsArePresent()
{
var namedArgument = new NamedArgument <string>("name", v => { });
var configuration = new CommandLineConfiguration(
new[] { namedArgument },
NoLongAliases,
NoRequiredArguments,
NoHelp);
var testee = new CommandLineParser(configuration);
var result = testee.Parse(new[] { "-name", "value" });
result.Succeeded.Should().BeTrue();
}
public bool Is(string option_name, int namespace_id = 1)
{
if (this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(option_name))
{
NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(option_name);
if (arg.Turn.Matched)
{
return(arg.Turn.Value == ON);
}
return(true);
}
else
{
return(false);
}
}
public static List <IArgument> GetArguments()
{
var idArgument = new NamedArgument()
{
Name = "id"
};
var newItemCommand = new NewItemCommand()
{
Name = "newitem"
};
var nameArgument = new NamedArgument()
{
Name = "name"
};
var fullSwitch = new SwitchArgument()
{
Name = "full"
};
var exampleSwitch = new SwitchArgument()
{
Name = "example"
};
var cmdCmd = new CmdCommand()
{
Name = "command", Aliases = new string[] { "cmd" }
};
var helpCommand = new HelpCommand()
{
Name = "help", ArgumentSequence = new List <IArgument> {
nameArgument
}
};
var startCommand = new StartCommand()
{
Name = "start", RequiredArguments = new List <IArgument>()
{
idArgument
}
};
var lst = new List <IArgument>()
{
helpCommand, startCommand, idArgument, newItemCommand, nameArgument, fullSwitch, exampleSwitch, cmdCmd
};
return(lst);
}
private NamedArgument <string> AddNamedArgument(string name, string valuePlaceholder, string description, Optional <IEnumerable <string> > allowedValues)
{
var namedArgument = new NamedArgument <string>(name, _)
{
AllowedValues = allowedValues
};
var namedHelp = new NamedHelp <string>(namedArgument)
{
ValuePlaceholder = valuePlaceholder,
Description = description
};
this.arguments.Add(namedArgument);
this.help.Add(namedHelp);
return(namedArgument);
}
public void Fails_WhenRequiredNamedArgumentIsMissing()
{
var namedArgument = new NamedArgument <string>("name", v => { });
var configuration = new CommandLineConfiguration(
new[] { namedArgument },
NoLongAliases,
new[] { namedArgument },
NoHelp);
var testee = new CommandLineParser(configuration);
var result = testee.Parse(new string[] { });
result.Should()
.BeFailedParsingResult()
.WithMessage(Errors.Errors.RequiredNamedArgumentIsMissing("name"));
}
public void Add(NamedArgument arg)
{
if (args != null)
{
NamedArgument[] array = new NamedArgument[args.Length + 1];
for (int i = 0; i < args.Length; i++)
{
array[i] = args[i];
}
array[array.Length - 1] = arg;
args = array;
count = args.Length;
return;
}
if (count == 0)
{
arg1 = arg;
}
else if (count == 1)
{
arg2 = arg;
}
else if (count == 2)
{
arg3 = arg;
}
else if (count == 3)
{
arg4 = arg;
}
else
{
args = new NamedArgument[5];
args[0] = arg1;
args[1] = arg2;
args[2] = arg3;
args[3] = arg4;
args[4] = arg;
arg1 = default(NamedArgument);
arg2 = default(NamedArgument);
arg3 = default(NamedArgument);
arg4 = default(NamedArgument);
}
count++;
}
public bool TryGetArg(string name, out NamedArgument arg)
{
if (count == 0)
{
arg = default(NamedArgument);
return(false);
}
if (args != null)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i].label == name)
{
arg = args[i];
return(true);
}
}
}
else
{
if (count >= 1 && arg1.label == name)
{
arg = arg1;
return(true);
}
if (count >= 2 && arg2.label == name)
{
arg = arg2;
return(true);
}
if (count >= 3 && arg3.label == name)
{
arg = arg3;
return(true);
}
if (count >= 4 && arg4.label == name)
{
arg = arg4;
return(true);
}
}
arg = default(NamedArgument);
return(false);
}
public string this[string option_name, int namespace_id = 1]
{
get
{
if (this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(option_name))
{
NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(option_name);
if (arg.Turn.Matched)
{
return(arg.Turn.Value);
}
return(arg.Value.Matched ? arg.Value.Value : null);
}
else
{
return(null);
}
}
}
//
// If throwIfMissingMetadata is false, returns null rather than throwing a MissingMetadataException.
//
internal sealed override IList <CustomAttributeNamedArgument> GetNamedArguments(bool throwIfMissingMetadata)
{
LowLevelListWithIList <CustomAttributeNamedArgument> customAttributeNamedArguments = new LowLevelListWithIList <CustomAttributeNamedArgument>();
foreach (NamedArgumentHandle namedArgumentHandle in _customAttribute.NamedArguments)
{
NamedArgument namedArgument = namedArgumentHandle.GetNamedArgument(_reader);
string memberName = namedArgument.Name.GetString(_reader);
bool isField = (namedArgument.Flags == NamedArgumentMemberKind.Field);
Exception? exception = null;
RuntimeTypeInfo?argumentType = namedArgument.Type.TryResolve(_reader, new TypeContext(null, null), ref exception);
if (argumentType == null)
{
if (throwIfMissingMetadata)
{
throw exception !;
}
else
{
return(null);
}
}
object? value;
Exception e = namedArgument.Value.TryParseConstantValue(_reader, out value);
if (e != null)
{
if (throwIfMissingMetadata)
{
throw e;
}
else
{
return(null);
}
}
CustomAttributeTypedArgument typedValue = WrapInCustomAttributeTypedArgument(value, argumentType);
customAttributeNamedArguments.Add(CreateCustomAttributeNamedArgument(this.AttributeType, memberName, isField, typedValue));
}
return(customAttributeNamedArguments);
}
public virtual Differences VisitNamedArgument(NamedArgument namedArgument1, NamedArgument namedArgument2){
Differences differences = new Differences(namedArgument1, namedArgument2);
if (namedArgument1 == null || namedArgument2 == null){
if (namedArgument1 != namedArgument2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
NamedArgument changes = (NamedArgument)namedArgument2.Clone();
NamedArgument deletions = (NamedArgument)namedArgument2.Clone();
NamedArgument insertions = (NamedArgument)namedArgument2.Clone();
if (namedArgument1.IsCustomAttributeProperty == namedArgument2.IsCustomAttributeProperty) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
Differences diff = this.VisitIdentifier(namedArgument1.Name, namedArgument2.Name);
if (diff == null){Debug.Assert(false); return differences;}
changes.Name = diff.Changes as Identifier;
deletions.Name = diff.Deletions as Identifier;
insertions.Name = diff.Insertions as Identifier;
Debug.Assert(diff.Changes == changes.Name && diff.Deletions == deletions.Name && diff.Insertions == insertions.Name);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitExpression(namedArgument1.Value, namedArgument2.Value);
if (diff == null){Debug.Assert(false); return differences;}
changes.Value = diff.Changes as Expression;
deletions.Value = diff.Deletions as Expression;
insertions.Value = diff.Insertions as Expression;
Debug.Assert(diff.Changes == changes.Value && diff.Deletions == deletions.Value && diff.Insertions == insertions.Value);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
private void GetCustomAttributeNamedArguments(ExpressionList/*!*/ arguments, ushort numNamed, MemoryCursor/*!*/ sigReader)
{
for (int j = 0; j < numNamed; j++)
{
int nameTag = sigReader.ReadByte();
bool mustBox = sigReader.Byte(0) == (byte)ElementType.BoxedEnum;
TypeNode/*!*/ vType = this.ParseTypeSignature(sigReader);
Identifier id = sigReader.ReadIdentifierFromSerString();
object val = this.GetCustomAttributeLiteralValue(sigReader, ref vType);
Literal lit = val as Literal;
if (lit == null) lit = new Literal(val, vType);
NamedArgument narg = new NamedArgument(id, lit);
narg.Type = vType;
narg.IsCustomAttributeProperty = nameTag == 0x54;
narg.ValueIsBoxed = mustBox;
arguments.Add(narg);
}
}
public override Expression VisitNamedArgument(NamedArgument namedArgument)
{
if (namedArgument == null) return null;
return base.VisitNamedArgument((NamedArgument)namedArgument.Clone());
}
public override Expression VisitNamedArgument(NamedArgument namedArgument)
{
throw new ApplicationException("unimplemented");
}
public virtual void VisitNamedArgument(NamedArgument namedArgument)
{
if (namedArgument == null) return;
this.VisitExpression(namedArgument.Value);
}
public virtual Expression VisitNamedArgument(NamedArgument namedArgument){
if (namedArgument == null) return null;
namedArgument.Value = this.VisitExpression(namedArgument.Value);
return namedArgument;
}
private void ParseAttributes(ref List<SourceCustomAttribute>/*?*/ sourceAttributes, bool globalAttributes, TokenSet followers) {
while (this.currentToken == Token.LeftBracket) {
int position = this.scanner.CurrentDocumentPosition();
this.GetNextToken();
AttributeTargets target = this.ParseAttributeTarget();
if (globalAttributes) {
if (target != AttributeTargets.Assembly && target != AttributeTargets.Module) {
this.scanner.RestoreDocumentPosition(position);
this.currentToken = Token.None;
this.GetNextToken();
return;
}
}
while (true) {
Expression expr = this.ParseExpression(followers|Token.Comma|Token.RightBracket);
MethodCall/*?*/ mcall = expr as MethodCall;
if (mcall != null && (mcall.MethodExpression is SimpleName || mcall.MethodExpression is QualifiedName || mcall.MethodExpression is AliasQualifiedName)) {
AttributeTypeExpression type = new AttributeTypeExpression(mcall.MethodExpression);
List<Expression> arguments = new List<Expression>(mcall.OriginalArguments);
bool seenNamedArgument = false;
for (int i = 0, n = arguments.Count; i < n; i++) {
Assignment/*?*/ assignment = arguments[i] as Assignment;
if (assignment == null) {
if (seenNamedArgument)
this.HandleError(arguments[i].SourceLocation, Error.NamedArgumentExpected);
continue;
}
SimpleName/*?*/ name = assignment.Target.Expression as SimpleName;
if (name == null) {
this.HandleError(assignment.Target.SourceLocation, Error.ExpectedIdentifier);
name = new SimpleName(Dummy.Name, assignment.Target.SourceLocation, false);
}
seenNamedArgument = true;
arguments[i] = new NamedArgument(name, assignment.Source, assignment.SourceLocation);
}
if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1);
sourceAttributes.Add(new SourceCustomAttribute(target, type, arguments, mcall.SourceLocation));
} else if (expr is SimpleName || expr is QualifiedName || expr is AliasQualifiedName) {
AttributeTypeExpression type = new AttributeTypeExpression(expr);
if (sourceAttributes == null) sourceAttributes = new List<SourceCustomAttribute>(1);
sourceAttributes.Add(new SourceCustomAttribute(target, type, new List<Expression>(0), expr.SourceLocation));
} else {
this.HandleError(expr.SourceLocation, Error.ExpectedIdentifier);
}
if (this.currentToken != Token.Comma) break;
this.GetNextToken();
}
this.Skip(Token.RightBracket);
}
if (sourceAttributes != null) sourceAttributes.TrimExcess();
}
public virtual Expression VisitNamedArgument(NamedArgument namedArgument, NamedArgument changes, NamedArgument deletions, NamedArgument insertions){
this.UpdateSourceContext(namedArgument, changes);
if (namedArgument == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return namedArgument;
}
public virtual Expression VisitNamedArgument(NamedArgument namedArgument1, NamedArgument namedArgument2)
{
if (namedArgument1 == null) return null;
if (namedArgument2 == null)
namedArgument1.Value = this.VisitExpression(namedArgument1.Value, null);
else
namedArgument1.Value = this.VisitExpression(namedArgument1.Value, namedArgument2.Value);
return namedArgument1;
}
