本文整理汇总了C#中Microsoft.CodeAnalysis.CSharp.Symbol.GetIsVararg方法的典型用法代码示例。如果您正苦于以下问题:C# Symbol.GetIsVararg方法的具体用法?C# Symbol.GetIsVararg怎么用?C# Symbol.GetIsVararg使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Microsoft.CodeAnalysis.CSharp.Symbol
的用法示例。
在下文中一共展示了Symbol.GetIsVararg方法的2个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: AnalyzeArguments
private static ArgumentAnalysisResult AnalyzeArguments(
Symbol symbol,
AnalyzedArguments arguments,
bool isMethodGroupConversion,
bool expanded)
{
Debug.Assert((object)symbol != null);
Debug.Assert(arguments != null);
ImmutableArray<ParameterSymbol> parameters = symbol.GetParameters();
// The easy out is that we have no named arguments and are in normal form.
if (!expanded && arguments.Names.Count == 0)
{
return AnalyzeArgumentsForNormalFormNoNamedArguments(parameters, arguments, isMethodGroupConversion, symbol.GetIsVararg());
}
// We simulate an additional non-optional parameter for a vararg method.
int argumentCount = arguments.Arguments.Count;
int[] parametersPositions = null;
int? unmatchedArgumentIndex = null;
bool? unmatchedArgumentIsNamed = null;
// Try to map every argument position to a formal parameter position:
for (int argumentPosition = 0; argumentPosition < argumentCount; ++argumentPosition)
{
// We use -1 as a sentinel to mean that no parameter was found that corresponded to this argument.
bool isNamedArgument;
int parameterPosition = CorrespondsToAnyParameter(parameters, expanded, arguments, argumentPosition, out isNamedArgument) ?? -1;
if (parameterPosition == -1 && unmatchedArgumentIndex == null)
{
unmatchedArgumentIndex = argumentPosition;
unmatchedArgumentIsNamed = isNamedArgument;
}
if (parameterPosition != argumentPosition && parametersPositions == null)
{
parametersPositions = new int[argumentCount];
for (int i = 0; i < argumentPosition; ++i)
{
parametersPositions[i] = i;
}
}
if (parametersPositions != null)
{
parametersPositions[argumentPosition] = parameterPosition;
}
}
ParameterMap argsToParameters = new ParameterMap(parametersPositions, argumentCount);
// We have analyzed every argument and tried to make it correspond to a particular parameter.
// There are now three questions we must answer:
//
// (1) Is there any argument without a corresponding parameter?
// (2) was there any named argument that specified a parameter that was already
// supplied with a positional parameter?
// (3) Is there any non-optional parameter without a corresponding argument?
//
// If the answer to any of these questions is "yes" then the method is not applicable.
// It is possible that the answer to any number of these questions is "yes", and so
// we must decide which error condition to prioritize when reporting the error,
// should we need to report why a given method is not applicable. We prioritize
// them in the given order.
// (1) Is there any argument without a corresponding parameter?
if (unmatchedArgumentIndex != null)
{
if (unmatchedArgumentIsNamed.Value)
{
return ArgumentAnalysisResult.NoCorrespondingNamedParameter(unmatchedArgumentIndex.Value);
}
else
{
return ArgumentAnalysisResult.NoCorrespondingParameter(unmatchedArgumentIndex.Value);
}
}
// (2) was there any named argument that specified a parameter that was already
// supplied with a positional parameter?
int? nameUsedForPositional = NameUsedForPositional(arguments, argsToParameters);
if (nameUsedForPositional != null)
{
return ArgumentAnalysisResult.NameUsedForPositional(nameUsedForPositional.Value);
}
// (3) Is there any non-optional parameter without a corresponding argument?
int? requiredParameterMissing = CheckForMissingRequiredParameter(argsToParameters, parameters, isMethodGroupConversion, expanded);
if (requiredParameterMissing != null)
{
return ArgumentAnalysisResult.RequiredParameterMissing(requiredParameterMissing.Value);
}
//.........这里部分代码省略.........
示例2: MakeArguments
/// <summary>
/// Rewrites arguments of an invocation according to the receiving method or indexer.
/// It is assumed that each argument has already been lowered, but we may need
/// additional rewriting for the arguments, such as generating a params array, re-ordering
/// arguments based on <paramref name="argsToParamsOpt"/> map, inserting arguments for optional parameters, etc.
/// <paramref name="optionalParametersMethod"/> is the method used for values of any optional parameters.
/// For indexers, this method must be an accessor, and for methods it must be the method
/// itself. <paramref name="optionalParametersMethod"/> is needed for indexers since getter and setter
/// may have distinct optional parameter values.
/// </summary>
private ImmutableArray<BoundExpression> MakeArguments(
SyntaxNode syntax,
ImmutableArray<BoundExpression> rewrittenArguments,
Symbol methodOrIndexer,
MethodSymbol optionalParametersMethod,
bool expanded,
ImmutableArray<int> argsToParamsOpt,
ref ImmutableArray<RefKind> argumentRefKindsOpt,
out ImmutableArray<LocalSymbol> temps,
bool invokedAsExtensionMethod = false,
ThreeState enableCallerInfo = ThreeState.Unknown)
{
// Either the methodOrIndexer is a property, in which case the method used
// for optional parameters is an accessor of that property (or an overridden
// property), or the methodOrIndexer is used for optional parameters directly.
Debug.Assert(((methodOrIndexer.Kind == SymbolKind.Property) && optionalParametersMethod.IsAccessor()) ||
ReferenceEquals(methodOrIndexer, optionalParametersMethod));
// We need to do a fancy rewrite under the following circumstances:
// (1) a params array is being used; we need to generate the array.
// (2) there were named arguments that reordered the arguments; we might
// have to generate temporaries to ensure that the arguments are
// evaluated in source code order, not the actual call order.
// (3) there were optional parameters that had no corresponding arguments.
//
// If none of those are the case then we can just take an early out.
// An applicable "vararg" method could not possibly be applicable in its expanded
// form, and cannot possibly have named arguments or used optional parameters,
// because the __arglist() argument has to be positional and in the last position.
if (methodOrIndexer.GetIsVararg())
{
Debug.Assert(rewrittenArguments.Length == methodOrIndexer.GetParameterCount() + 1);
Debug.Assert(argsToParamsOpt.IsDefault);
Debug.Assert(!expanded);
temps = default(ImmutableArray<LocalSymbol>);
return rewrittenArguments;
}
var receiverNamedType = invokedAsExtensionMethod ?
((MethodSymbol)methodOrIndexer).Parameters[0].Type as NamedTypeSymbol :
methodOrIndexer.ContainingType;
bool isComReceiver = (object)receiverNamedType != null && receiverNamedType.IsComImport;
if (rewrittenArguments.Length == methodOrIndexer.GetParameterCount() &&
argsToParamsOpt.IsDefault &&
!expanded &&
!isComReceiver)
{
temps = default(ImmutableArray<LocalSymbol>);
return rewrittenArguments;
}
// We have:
// * a list of arguments, already converted to their proper types,
// in source code order. Some optional arguments might be missing.
// * a map showing which parameter each argument corresponds to. If
// this is null, then the argument to parameter mapping is one-to-one.
// * the ref kind of each argument, in source code order. That is, whether
// the argument was marked as ref, out, or value (neither).
// * a method symbol.
// * whether the call is expanded or normal form.
// We rewrite the call so that:
// * if in its expanded form, we create the params array.
// * if the call requires reordering of arguments because of named arguments, temporaries are generated as needed
// Doing this transformation can move around refness in interesting ways. For example, consider
//
// A().M(y : ref B()[C()], x : out D());
//
// This will be created as a call with receiver A(), symbol M, argument list ( B()[C()], D() ),
// name list ( y, x ) and ref list ( ref, out ). We can rewrite this into temporaries:
//
// A().M(
// seq ( ref int temp_y = ref B()[C()], out D() ),
// temp_y );
//
// Now we have a call with receiver A(), symbol M, argument list as shown, no name list,
// and ref list ( out, value ). We do not want to pass a *ref* to temp_y; the temporary
// storage is not the thing being ref'd! We want to pass the *value* of temp_y, which
// *contains* a reference.
// We attempt to minimize the number of temporaries required. Arguments which neither
// produce nor observe a side effect can be placed into their proper position without
// recourse to a temporary. For example:
//.........这里部分代码省略.........