本文整理汇总了C#中CSharpSyntaxNode.IsAnonymousFunction方法的典型用法代码示例。如果您正苦于以下问题:C# CSharpSyntaxNode.IsAnonymousFunction方法的具体用法?C# CSharpSyntaxNode.IsAnonymousFunction怎么用?C# CSharpSyntaxNode.IsAnonymousFunction使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类CSharpSyntaxNode
的用法示例。
在下文中一共展示了CSharpSyntaxNode.IsAnonymousFunction方法的9个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: BoundLambda
public BoundLambda(CSharpSyntaxNode syntax, BoundBlock body, ImmutableArray<Diagnostic> diagnostics, Binder binder, TypeSymbol delegateType, bool inferReturnType)
: this(syntax, (LambdaSymbol)binder.ContainingMemberOrLambda, body, diagnostics, binder, delegateType)
{
if (inferReturnType)
{
this._inferredReturnType = InferReturnType(
this.Body,
this.Binder,
delegateType,
this.Symbol.IsAsync,
ref this._inferredReturnTypeUseSiteDiagnostics,
out this._refKind,
out this._inferredFromSingleType);
#if DEBUG
_hasInferredReturnType = true;
#endif
}
Debug.Assert(
syntax.IsAnonymousFunction() || // lambda expressions
syntax is ExpressionSyntax && LambdaUtilities.IsLambdaBody(syntax, allowReducedLambdas: true) || // query lambdas
LambdaUtilities.IsQueryPairLambda(syntax) // "pair" lambdas in queries
);
}
示例2: GetLambdaEnclosingBinder
/// <summary>
/// Performs the same function as GetEnclosingBinder, but is known to take place within a
/// specified lambda. Walks up the syntax hierarchy until a node with an associated binder
/// is found.
/// </summary>
/// <remarks>
/// CONSIDER: can this share code with MemberSemanticModel.GetEnclosingBinder?
///
/// Returned binder doesn't need to have <see cref="BinderFlags.SemanticModel"/> set - the caller will add it.
/// </remarks>
private static Binder GetLambdaEnclosingBinder(int position, CSharpSyntaxNode startingNode, CSharpSyntaxNode containingLambda, Binder lambdaBinder)
{
Debug.Assert(containingLambda.IsAnonymousFunction());
Debug.Assert(LookupPosition.IsInAnonymousFunctionOrQuery(position, containingLambda));
return GetEnclosingBinder(startingNode, position, lambdaBinder, containingLambda);
}
示例3: NodeIsExplicitType
private static bool NodeIsExplicitType(CSharpSyntaxNode node, CSharpSyntaxNode lambda)
{
Debug.Assert(node != null);
Debug.Assert(lambda != null);
Debug.Assert(lambda.IsAnonymousFunction() || lambda.IsQuery());
// UNDONE;
return false;
}
示例4: GetLambdaEnclosingBinder
/// <summary>
/// Performs the same function as GetEnclosingBinder, but is known to take place within a
/// specified lambda. Walks up the syntax hierarchy until a node with an associated binder
/// is found.
/// </summary>
/// <remarks>
/// CONSIDER: can this share code with MemberSemanticModel.GetEnclosingBinder?
///
/// Returned binder doesn't need to have <see cref="BinderFlags.SemanticModel"/> set - the caller will add it.
/// </remarks>
private static Binder GetLambdaEnclosingBinder(int position, CSharpSyntaxNode startingNode, CSharpSyntaxNode containingLambda, Binder lambdaBinder)
{
Debug.Assert(containingLambda.IsAnonymousFunction());
Debug.Assert(LookupPosition.IsInAnonymousFunctionOrQuery(position, containingLambda));
var current = startingNode;
while (current != containingLambda)
{
Debug.Assert(current != null);
StatementSyntax stmt = current as StatementSyntax;
if (stmt != null)
{
if (LookupPosition.IsInStatementScope(position, stmt))
{
Binder binder = lambdaBinder.GetBinder(current);
if (binder != null)
{
return AdjustBinderForPositionWithinStatement(position, binder, stmt);
}
}
}
else if (current.Kind == SyntaxKind.CatchClause)
{
if (LookupPosition.IsInCatchBlockScope(position, (CatchClauseSyntax)current))
{
Binder binder = lambdaBinder.GetBinder(current);
if (binder != null)
{
return binder;
}
}
}
else if (current.Kind == SyntaxKind.CatchFilterClause)
{
if (LookupPosition.IsInCatchFilterScope(position, (CatchFilterClauseSyntax)current))
{
Binder binder = lambdaBinder.GetBinder(current);
if (binder != null)
{
return binder;
}
}
}
else if (current.IsAnonymousFunction())
{
if (LookupPosition.IsInAnonymousFunctionOrQuery(position, current))
{
Binder binder = lambdaBinder.GetBinder(current);
if (binder != null)
{
return binder;
}
}
}
else
{
// If this ever breaks, make sure that all callers of
// CanHaveAssociatedLocalBinder are in sync.
Debug.Assert(!current.CanHaveAssociatedLocalBinder());
}
current = current.ParentOrStructuredTriviaParent;
}
return lambdaBinder;
}
示例5: AnalyzeAnonymousFunction
// An anonymous function can be of the form:
//
// delegate { } (missing parameter list)
// delegate (int x) { } (typed parameter list)
// x => ... (type-inferred parameter list)
// (x) => ... (type-inferred parameter list)
// (x, y) => ... (type-inferred parameter list)
// ( ) => ... (typed parameter list)
// (ref int x) => ... (typed parameter list)
// (int x, out int y) => ... (typed parameter list)
//
// and so on. We want to canonicalize these various ways of writing the signatures.
//
// If we are in the first case then the name, modifier and type arrays are all null.
// If we have a parameter list then the names array is non-null, but possibly empty.
// If we have types then the types array is non-null, but possibly empty.
// If we have no modifiers then the modifiers array is null; if we have any modifiers
// then the modifiers array is non-null and not empty.
private Tuple<ImmutableArray<RefKind>, ImmutableArray<TypeSymbol>, ImmutableArray<string>, bool> AnalyzeAnonymousFunction(
CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.IsAnonymousFunction());
var names = default(ImmutableArray<string>);
var refKinds = default(ImmutableArray<RefKind>);
var types = default(ImmutableArray<TypeSymbol>);
bool isAsync = false;
var namesBuilder = ArrayBuilder<string>.GetInstance();
SeparatedSyntaxList<ParameterSyntax>? parameterSyntaxList = null;
bool hasSignature;
switch (syntax.Kind)
{
default:
case SyntaxKind.SimpleLambdaExpression:
// x => ...
hasSignature = true;
var simple = (SimpleLambdaExpressionSyntax)syntax;
namesBuilder.Add(simple.Parameter.Identifier.ValueText);
isAsync = (simple.AsyncKeyword.CSharpKind() == SyntaxKind.AsyncKeyword);
break;
case SyntaxKind.ParenthesizedLambdaExpression:
// (T x, U y) => ...
// (x, y) => ...
hasSignature = true;
var paren = (ParenthesizedLambdaExpressionSyntax)syntax;
parameterSyntaxList = paren.ParameterList.Parameters;
isAsync = (paren.AsyncKeyword.CSharpKind() == SyntaxKind.AsyncKeyword);
break;
case SyntaxKind.AnonymousMethodExpression:
// delegate (int x) { }
// delegate { }
var anon = (AnonymousMethodExpressionSyntax)syntax;
hasSignature = anon.ParameterList != null;
if (hasSignature)
{
parameterSyntaxList = anon.ParameterList.Parameters;
}
isAsync = (anon.AsyncKeyword.CSharpKind() == SyntaxKind.AsyncKeyword);
break;
}
if (parameterSyntaxList != null)
{
var hasExplicitlyTypedParameterList = true;
var allValue = true;
var typesBuilder = ArrayBuilder<TypeSymbol>.GetInstance();
var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance();
// In the batch compiler case we probably should have given a syntax error if the
// user did something like (int x, y)=>x+y -- but in the IDE scenario we might be in
// this case. If we are, then rather than try to make partial deductions from the
// typed formal parameters, simply bail out and treat it as an untyped lambda.
//
// However, we still want to give errors on every bad type in the list, even if one
// is missing.
foreach (var p in parameterSyntaxList.Value)
{
if (p.IsArgList)
{
Error(diagnostics, ErrorCode.ERR_IllegalVarArgs, p);
continue;
}
var typeSyntax = p.Type;
TypeSymbol type = null;
var refKind = RefKind.None;
if (typeSyntax == null)
{
hasExplicitlyTypedParameterList = false;
}
else
{
type = BindType(typeSyntax, diagnostics);
//.........这里部分代码省略.........
示例6: BindAnonymousFunction
private UnboundLambda BindAnonymousFunction(CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.IsAnonymousFunction());
var results = AnalyzeAnonymousFunction(syntax, diagnostics);
var refKinds = results.Item1;
var types = results.Item2;
var names = results.Item3;
var isAsync = results.Item4;
if (!types.IsDefault)
{
foreach (var type in types)
{
// UNDONE: Where do we report improper use of pointer types?
if ((object)type != null && type.IsStatic)
{
Error(diagnostics, ErrorCode.ERR_ParameterIsStaticClass, syntax, type);
}
}
}
var lambda = new UnboundLambda(syntax, this, refKinds, types, names, isAsync);
if (!names.IsDefault)
{
var binder = new LocalScopeBinder(this.ContainingMemberOrLambda as MethodSymbol, this);
for (int n = 0; n < names.Length; ++n)
{
string name = lambda.ParameterName(n);
binder.ValidateLambdaParameterNameConflictsInScope(lambda.ParameterLocation(n), name, diagnostics);
}
}
return lambda;
}
示例7: UnboundLambda
public UnboundLambda(
CSharpSyntaxNode syntax,
Binder binder,
ImmutableArray<RefKind> refKinds,
ImmutableArray<TypeSymbol> types,
ImmutableArray<string> names,
bool isAsync,
bool hasErrors = false)
: base(BoundKind.UnboundLambda, syntax, null, hasErrors || !types.IsDefault && types.Any(SymbolKind.ErrorType))
{
Debug.Assert(binder != null);
Debug.Assert(syntax.IsAnonymousFunction());
this.Data = new PlainUnboundLambdaState(this, binder, names, types, refKinds, isAsync);
}
示例8: IsInAnonymousFunctionOrQuery
internal static bool IsInAnonymousFunctionOrQuery(int position, CSharpSyntaxNode lambdaExpressionOrQueryNode)
{
Debug.Assert(lambdaExpressionOrQueryNode.IsAnonymousFunction() || lambdaExpressionOrQueryNode.IsQuery());
SyntaxToken firstIncluded;
CSharpSyntaxNode body;
switch (lambdaExpressionOrQueryNode.Kind())
{
case SyntaxKind.SimpleLambdaExpression:
SimpleLambdaExpressionSyntax simple = (SimpleLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = simple.Parameter.Identifier;
body = simple.Body;
break;
case SyntaxKind.ParenthesizedLambdaExpression:
ParenthesizedLambdaExpressionSyntax parenthesized = (ParenthesizedLambdaExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = parenthesized.ParameterList.OpenParenToken;
body = parenthesized.Body;
break;
case SyntaxKind.AnonymousMethodExpression:
AnonymousMethodExpressionSyntax anon = (AnonymousMethodExpressionSyntax)lambdaExpressionOrQueryNode;
firstIncluded = anon.DelegateKeyword;
body = anon.Block;
break;
default:
// OK, so we have some kind of query clause. They all start with a keyword token, so we'll skip that.
firstIncluded = lambdaExpressionOrQueryNode.GetFirstToken().GetNextToken();
return IsBetweenTokens(position, firstIncluded, lambdaExpressionOrQueryNode.GetLastToken().GetNextToken());
}
var bodyStatement = body as StatementSyntax;
var firstExcluded = bodyStatement != null ?
GetFirstExcludedToken(bodyStatement) :
(SyntaxToken)SyntaxNavigator.Instance.GetNextToken(body, predicate: null, stepInto: null);
return IsBetweenTokens(position, firstIncluded, firstExcluded);
}
示例9: BindAnonymousFunction
private UnboundLambda BindAnonymousFunction(CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.IsAnonymousFunction());
var results = AnalyzeAnonymousFunction(syntax, diagnostics);
var refKinds = results.Item1;
var types = results.Item2;
var names = results.Item3;
var isAsync = results.Item4;
if (!types.IsDefault)
{
foreach (var type in types)
{
// UNDONE: Where do we report improper use of pointer types?
if ((object)type != null && type.IsStatic)
{
Error(diagnostics, ErrorCode.ERR_ParameterIsStaticClass, syntax, type);
}
}
}
var lambda = new UnboundLambda(syntax, this, refKinds, types, names, isAsync);
if (!names.IsDefault)
{
var binder = new LocalScopeBinder(this);
var pNames = PooledHashSet<string>.GetInstance();
for (int i = 0; i < lambda.ParameterCount; i ++)
{
var name = lambda.ParameterName(i);
if (string.IsNullOrEmpty(name))
{
continue;
}
if (pNames.Contains(name))
{
// The parameter name '{0}' is a duplicate
diagnostics.Add(ErrorCode.ERR_DuplicateParamName, lambda.ParameterLocation(i), name);
}
else
{
pNames.Add(name);
binder.ValidateLambdaParameterNameConflictsInScope(lambda.ParameterLocation(i), name, diagnostics);
}
}
pNames.Free();
}
return lambda;
}