//private Queue<Location> CreatePathFrom(Location start) //{ // var synclist = Locations; // var position = synclist.FindIndex(l => l == start); // var queue = new Queue<Location>(synclist); // for (int i = 0; i < position; i++) // queue.Dequeue(); // return queue; //} public override void OnStart() { LastIndex = 0; currentLocation = null; Locations.Clear(); Print("Starting breadcrumb system!"); var tank = WoWParty.Members.OrderByDescending(m => m.MaxHealth).First() ?? WoWUnit.Invalid; if (tank.IsValid) { if (tank.InLoS) { FollowUnit = tank; UnitFacing = tank.Facing; Locations.Add(FollowUnit.Location); currentLocation = Locations[0]; } else { Print("Get in LoS of {0}.", tank.Name); Stop(); } } else { Print("No suitable unit to follow found, are you in group?"); Stop(); } }
public IntValueNode(Location?location, byte value) { Location = location; _byteValue = value; _shortValue = value; }
public EdgeLabel(string text, Location?location) { this.text = text; this.location = location; }
public void EmitPredefined(EmitContext ec, MethodSpec method, Arguments Arguments, bool statement = false, Location?loc = null) { Expression instance_copy = null; if (!HasAwaitArguments && ec.HasSet(BuilderContext.Options.AsyncBody)) { HasAwaitArguments = Arguments != null && Arguments.ContainsEmitWithAwait(); if (HasAwaitArguments && InstanceExpressionOnStack) { throw new NotSupportedException(); } } OpCode call_op; LocalTemporary lt = null; if (method.IsStatic) { call_op = OpCodes.Call; } else { call_op = IsVirtualCallRequired(InstanceExpression, method) ? OpCodes.Callvirt : OpCodes.Call; if (HasAwaitArguments) { instance_copy = InstanceExpression.EmitToField(ec); var ie = new InstanceEmitter(instance_copy, IsAddressCall(instance_copy, call_op, method.DeclaringType)); if (Arguments == null) { ie.EmitLoad(ec, true); } } else if (!InstanceExpressionOnStack) { var ie = new InstanceEmitter(InstanceExpression, IsAddressCall(InstanceExpression, call_op, method.DeclaringType)); ie.Emit(ec, ConditionalAccess); if (DuplicateArguments) { ec.Emit(OpCodes.Dup); if (Arguments != null && Arguments.Count != 0) { lt = new LocalTemporary(ie.GetStackType(ec)); lt.Store(ec); instance_copy = lt; } } } } if (Arguments != null && !InstanceExpressionOnStack) { EmittedArguments = Arguments.Emit(ec, DuplicateArguments, HasAwaitArguments); if (EmittedArguments != null) { if (instance_copy != null) { var ie = new InstanceEmitter(instance_copy, IsAddressCall(instance_copy, call_op, method.DeclaringType)); ie.Emit(ec, ConditionalAccess); if (lt != null) { lt.Release(ec); } } EmittedArguments.Emit(ec); } } if (call_op == OpCodes.Callvirt && (InstanceExpression.Type.IsGenericParameter || InstanceExpression.Type.IsStructOrEnum)) { ec.Emit(OpCodes.Constrained, InstanceExpression.Type); } if (loc != null) { // // Emit explicit sequence point for expressions like Foo.Bar () to help debugger to // break at right place when LHS expression can be stepped-into // ec.MarkCallEntry(loc.Value); } // // Set instance expression to actual result expression. When it contains await it can be // picked up by caller // InstanceExpression = instance_copy; if (method.Parameters.HasArglist) { var varargs_types = GetVarargsTypes(method, Arguments); ec.Emit(call_op, method, varargs_types); } else { // // If you have: // this.DoFoo (); // and DoFoo is not virtual, you can omit the callvirt, // because you don't need the null checking behavior. // ec.Emit(call_op, method); } // // Pop the return value if there is one and stack should be empty // if (statement && method.ReturnType.Kind != MemberKind.Void) { ec.Emit(OpCodes.Pop); } }
/// <param name="symbol">The symbol to analyze.</param> /// <param name="reportDiagnostic">Action called to actually report a diagnostic.</param> /// <param name="isImplicitlyDeclaredConstructor">If the symbol is an implicitly declared constructor.</param> /// <param name="explicitLocation">A location to report the diagnostics for a symbol at. If null, then /// the location of the symbol will be used.</param> private void OnSymbolActionCore(ISymbol symbol, Action <Diagnostic> reportDiagnostic, bool isImplicitlyDeclaredConstructor, Location?explicitLocation = null) { Debug.Assert(IsPublicAPI(symbol)); ApiName publicApiName = GetPublicApiName(symbol); _visitedApiList.TryAdd(publicApiName.Name, default); _visitedApiList.TryAdd(publicApiName.NameWithNullability, default); List <Location> locationsToReport = new List <Location>(); if (explicitLocation != null) { locationsToReport.Add(explicitLocation); } else { var locations = isImplicitlyDeclaredConstructor ? symbol.ContainingType.Locations : symbol.Locations; locationsToReport.AddRange(locations.Where(l => l.IsInSource)); } ApiLine foundApiLine; if (_useNullability) { var hasPublicApiEntryWithNullability = _publicApiMap.TryGetValue(publicApiName.NameWithNullability, out foundApiLine); if (!hasPublicApiEntryWithNullability) { var hasPublicApiEntryWithoutNullability = _publicApiMap.TryGetValue(publicApiName.Name, out foundApiLine); if (!hasPublicApiEntryWithoutNullability) { reportDeclareNewApi(symbol, isImplicitlyDeclaredConstructor, publicApiName.NameWithNullability); } else { reportAnnotateApi(symbol, isImplicitlyDeclaredConstructor, publicApiName, foundApiLine.IsShippedApi); } } } else { var hasPublicApiEntryWithoutNullability = _publicApiMap.TryGetValue(publicApiName.Name, out foundApiLine); if (!hasPublicApiEntryWithoutNullability) { reportDeclareNewApi(symbol, isImplicitlyDeclaredConstructor, publicApiName.Name); } if (publicApiName.Name != publicApiName.NameWithNullability) { // '#nullable enable' would be useful and should be set reportDiagnosticAtLocations(ShouldAnnotateApiFilesRule, ImmutableDictionary <string, string> .Empty); } } if (symbol.Kind == SymbolKind.Method) { var method = (IMethodSymbol)symbol; var isMethodShippedApi = foundApiLine?.IsShippedApi == true; // Check if a public API is a constructor that makes this class instantiable, even though the base class // is not instantiable. That API pattern is not allowed, because it causes protected members of // the base class, which are not considered public APIs, to be exposed to subclasses of this class. if (!isMethodShippedApi && method.MethodKind == MethodKind.Constructor && method.ContainingType.TypeKind == TypeKind.Class && !method.ContainingType.IsSealed && method.ContainingType.BaseType != null && IsPublicApiCore(method.ContainingType.BaseType) && !CanTypeBeExtendedPublicly(method.ContainingType.BaseType)) { string errorMessageName = GetErrorMessageName(method, isImplicitlyDeclaredConstructor); ImmutableDictionary <string, string> propertyBag = ImmutableDictionary <string, string> .Empty; var locations = isImplicitlyDeclaredConstructor ? method.ContainingType.Locations : method.Locations; reportDiagnostic(Diagnostic.Create(ExposedNoninstantiableType, locations[0], propertyBag, errorMessageName)); } // Flag public API with optional parameters that violate backcompat requirements: https://github.com/dotnet/roslyn/blob/master/docs/Adding%20Optional%20Parameters%20in%20Public%20API.md. if (method.HasOptionalParameters()) { foreach (var overload in method.GetOverloads()) { if (!IsPublicAPI(overload)) { continue; } // Don't flag overloads which have identical params (e.g. overloading a generic and non-generic method with same parameter types). if (overload.Parameters.Length == method.Parameters.Length && overload.Parameters.Select(p => p.Type).SequenceEqual(method.Parameters.Select(p => p.Type))) { continue; } // RS0026: Symbol '{0}' violates the backcompat requirement: 'Do not add multiple overloads with optional parameters'. See '{1}' for details. var overloadHasOptionalParams = overload.HasOptionalParameters(); if (overloadHasOptionalParams) { // Flag only if 'method' is a new unshipped API with optional parameters. if (!isMethodShippedApi) { string errorMessageName = GetErrorMessageName(method, isImplicitlyDeclaredConstructor); reportDiagnosticAtLocations(AvoidMultipleOverloadsWithOptionalParameters, ImmutableDictionary <string, string> .Empty, errorMessageName, AvoidMultipleOverloadsWithOptionalParameters.HelpLinkUri); break; } } // RS0027: Symbol '{0}' violates the backcompat requirement: 'Public API with optional parameter(s) should have the most parameters amongst its public overloads'. See '{1}' for details. if (method.Parameters.Length <= overload.Parameters.Length) { // 'method' is unshipped: Flag regardless of whether the overload is shipped/unshipped. // 'method' is shipped: Flag only if overload is unshipped and has no optional parameters (overload will already be flagged with RS0026) if (!isMethodShippedApi) { string errorMessageName = GetErrorMessageName(method, isImplicitlyDeclaredConstructor); reportDiagnosticAtLocations(OverloadWithOptionalParametersShouldHaveMostParameters, ImmutableDictionary <string, string> .Empty, errorMessageName, OverloadWithOptionalParametersShouldHaveMostParameters.HelpLinkUri); break; } else if (!overloadHasOptionalParams) { var overloadPublicApiName = GetPublicApiName(overload); var isOverloadUnshipped = !lookupPublicApi(overloadPublicApiName, out ApiLine overloadPublicApiLine) || !overloadPublicApiLine.IsShippedApi; if (isOverloadUnshipped) { string errorMessageName = GetErrorMessageName(method, isImplicitlyDeclaredConstructor); reportDiagnosticAtLocations(OverloadWithOptionalParametersShouldHaveMostParameters, ImmutableDictionary <string, string> .Empty, errorMessageName, OverloadWithOptionalParametersShouldHaveMostParameters.HelpLinkUri); break; } } } } } } return; // local functions void reportDiagnosticAtLocations(DiagnosticDescriptor descriptor, ImmutableDictionary <string, string> propertyBag, params object[] args) { foreach (var location in locationsToReport) { reportDiagnostic(Diagnostic.Create(descriptor, location, propertyBag, args)); } } void reportDeclareNewApi(ISymbol symbol, bool isImplicitlyDeclaredConstructor, string publicApiName) { // TODO: workaround for https://github.com/dotnet/wpf/issues/2690 if (publicApiName == "XamlGeneratedNamespace.GeneratedInternalTypeHelper" || publicApiName == "XamlGeneratedNamespace.GeneratedInternalTypeHelper.GeneratedInternalTypeHelper() -> void") { return; } // Unshipped public API with no entry in public API file - report diagnostic. string errorMessageName = GetErrorMessageName(symbol, isImplicitlyDeclaredConstructor); // Compute public API names for any stale siblings to remove from unshipped text (e.g. during signature change of unshipped public API). var siblingPublicApiNamesToRemove = GetSiblingNamesToRemoveFromUnshippedText(symbol); ImmutableDictionary <string, string> propertyBag = ImmutableDictionary <string, string> .Empty .Add(PublicApiNamePropertyBagKey, publicApiName) .Add(MinimalNamePropertyBagKey, errorMessageName) .Add(PublicApiNamesOfSiblingsToRemovePropertyBagKey, siblingPublicApiNamesToRemove); reportDiagnosticAtLocations(DeclareNewApiRule, propertyBag, errorMessageName); } void reportAnnotateApi(ISymbol symbol, bool isImplicitlyDeclaredConstructor, ApiName publicApiName, bool isShipped) { // Public API missing annotations in public API file - report diagnostic. string errorMessageName = GetErrorMessageName(symbol, isImplicitlyDeclaredConstructor); ImmutableDictionary <string, string> propertyBag = ImmutableDictionary <string, string> .Empty .Add(PublicApiNamePropertyBagKey, publicApiName.Name) .Add(PublicApiNameWithNullabilityPropertyBagKey, publicApiName.NameWithNullability) .Add(MinimalNamePropertyBagKey, errorMessageName) .Add(PublicApiIsShippedPropertyBagKey, isShipped ? "true" : "false"); reportDiagnosticAtLocations(AnnotateApiRule, propertyBag, errorMessageName); } bool lookupPublicApi(ApiName overloadPublicApiName, out ApiLine overloadPublicApiLine) { if (_useNullability) { return(_publicApiMap.TryGetValue(overloadPublicApiName.NameWithNullability, out overloadPublicApiLine) || _publicApiMap.TryGetValue(overloadPublicApiName.Name, out overloadPublicApiLine)); } else { return(_publicApiMap.TryGetValue(overloadPublicApiName.Name, out overloadPublicApiLine)); } } }
/// <inheritdoc /> protected override void InspectMessage(int logEventId, EventLevel level, string message, Location?location = null) { m_forwardDiagnosticsTo?.InspectMessage(logEventId, level, message, location); var diagnostic = new Diagnostic(logEventId, level, message, location); if (m_preserveLogEvents) { m_capturedDiagnostics.Enqueue(diagnostic); } foreach (var observer in m_messageObservers) { observer.OnMessage(diagnostic); } if (level.IsError()) { Interlocked.Increment(ref m_errorCount); } }
public void Warning(Location?loc, string message) { log.Message(Log.MsgKind.WARNING, loc, message); }
public EnumValueNode(Location?location, string value) { Location = location; _value = value ?? throw new ArgumentNullException(nameof(value)); }
public UnionTypeExtensionNode WithLocation(Location?location) { return(new UnionTypeExtensionNode( location, Name, Directives, Types)); }
public DijkstraData(Location?from, long cost) { From = from; Cost = cost; Oppened = false; }
public GeometrySlowCollider(RWGeometry geometry, Location?location) { Geometry = geometry; Location = location ?? new Location(); }
public static IIntersectionable CreateFor(RWGeometry geometry, Location?location) => geometry.FindChildById(SectionId.CollisionPLG, recursive: true) == null ? new GeometrySlowCollider(geometry, location) : new GeometryTreeCollider(geometry, location);
void ILocationListener.OnLocationChanged(Location?location) { if (location?.Provider != LocationManager.GpsProvider) { Accuracy = float.NaN; return; } Accuracy = location.HasAccuracy ? location.Accuracy : float.NaN; if (_isNmeaSupported) { return; } // Not all Android devices support reporting NMEA, so we'll fallback to just generating // simple RMC and GGA message so the provider continues to work across multiple devices // $GPRMC: List <string> values = new List <string>(12); values.Add("$GPRMC"); DateTimeOffset d = DateTimeOffset.FromUnixTimeMilliseconds(location.Time); values.Add(d.ToString("hhmmss")); values.Add("A"); var lat = Math.Floor(Math.Abs(location.Latitude)); var latfrac = (Math.Abs(location.Latitude) - lat) * 60; values.Add($"{lat.ToString("00")}{latfrac.ToString(CultureInfo.InvariantCulture)}"); values.Add(location.Latitude < 0 ? "S" : "N"); var lon = Math.Floor(Math.Abs(location.Longitude)); var lonfrac = (Math.Abs(location.Longitude) - lon) * 60; values.Add($"{lon.ToString("000")}{lonfrac.ToString(CultureInfo.InvariantCulture)}"); values.Add(location.Longitude < 0 ? "W" : "E"); values.Add(location.HasSpeed ? location.Speed.ToString(CultureInfo.InvariantCulture) : ""); values.Add(location.HasBearing ? location.Bearing.ToString(CultureInfo.InvariantCulture) : ""); values.Add(d.ToString("ddMMyy")); values.Add(""); //Variation values.Add(""); //East/West NmeaMessage?.Invoke(this, string.Join(",", values) + "\n"); // $GPGGA: int satellites = 0; if (location.Extras != null && location.Extras.ContainsKey("satellites")) { satellites = Convert.ToInt32(location.Extras.Get("satellites")); } values = new List <string>(13); values.Add("$GPGGA"); values.Add(d.ToString("hhmmss")); values.Add($"{lat.ToString("00")}{latfrac.ToString(CultureInfo.InvariantCulture)}"); values.Add(location.Latitude < 0 ? "S" : "N"); values.Add($"{lon.ToString("000")}{lonfrac.ToString(CultureInfo.InvariantCulture)}"); values.Add(location.Longitude < 0 ? "W" : "E"); values.Add("1"); //Fix Quality: values.Add(satellites.ToString()); //Number of Satellites values.Add(""); //HDOP values.Add(location.HasAltitude ? location.Altitude.ToString(CultureInfo.InvariantCulture) : ""); values.Add("M"); //Altitude units values.Add(""); //Height of geoid above WGS84 ellipsoid values.Add(""); //Geoid height units values.Add(""); //Time since last DGPS update values.Add(""); //DGPS reference station id NmeaMessage?.Invoke(this, string.Join(",", values) + "\n"); }
public CardButton(Location?i_CardLocation) : base() { r_CardLocation = i_CardLocation; }
public override Tokenizer Tokenize(Character character) { if(location == null) { location = character.Location; startColumn = location.Value.Column; RootTokenizer.OnToken( parser => parser.ParseStringLiteral(() => stringBuilder.ToString(), GetStringLiteralRegion())); } if(justUninterpolated) { startColumn = character.Location.Column; justUninterpolated = false; } if(potentiallyInterpolated) { Tokenizer tokenizer; if(character.Char == '{') { stringBuilder.Append('{'); tokenizer = this; } else { tokenizer = OnFirstInterpolatedCharacter(character); } potentiallyInterpolated = false; endColumn = character.Location.Column; // TODO get rid of this? return tokenizer; } else if(potentiallyUninterpolated) { if(character.Char == '}') { stringBuilder.Append('}'); potentiallyUninterpolated = false; } else { OnError(character.Location, TokenizationError.UnexpectedRightCurlyBracket); } endColumn = character.Location.Column; return this; } else if(escaped) { OnEspacedCharacter(character); return this; } else { return OnRegularCharacter(character); } }
public override void OnTick() { if (FollowUnit.IsValid) { var newFacing = FollowUnit.Facing; var span = DateTime.Now - LastAddition; if (Math.Abs(newFacing - UnitFacing) > 0.3f || (span.TotalSeconds > 2 && FollowUnit.Distance > 4f)) { Locations.Add(FollowUnit.Location); UnitFacing = newFacing; LastAddition = DateTime.Now; } } if (!Manager.LocalPlayer.IsCasting && !Manager.LocalPlayer.IsClickMoving) { currentLocation = Locations[LastIndex]; if (currentLocation.HasValue && Manager.LocalPlayer.Location.DistanceTo(currentLocation.Value) < 3f && LastIndex + 1 < Locations.Count) currentLocation = Locations[LastIndex++]; if (currentLocation.HasValue && (FollowUnit.Distance > 6f || !FollowUnit.InLoS)) { Manager.LocalPlayer.ClickToMove(currentLocation.Value); } } }
public static bool IsLocationMaskedToPlayer(Location?whichLocation, Player_?whichPlayer) => throw new NotImplementedException();
public void Message(Location?loc, string message) { log.Message(Log.MsgKind.MESSAGE, loc, message); }
/// <summary> /// Hook for inspecting log messages on a logger /// </summary> protected virtual void InspectMessage(int logEventId, EventLevel level, string message, Location?location = null) { // Do nothing. Must be overridden to enable this functionality. }
public void Error(Location?loc, string message) { log.Message(Log.MsgKind.ERROR, loc, message); }
protected Expr(Location?location) { Location = location ?? new Location(0, 0); }
/// <param name="symbol">The symbol to analyze. Will also analyze implicit constructors too.</param> /// <param name="reportDiagnostic">Action called to actually report a diagnostic.</param> /// <param name="explicitLocation">A location to report the diagnostics for a symbol at. If null, then /// the location of the symbol will be used.</param> private void OnSymbolActionCore(ISymbol symbol, Action <Diagnostic> reportDiagnostic, Location?explicitLocation = null) { if (!IsPublicAPI(symbol)) { return; } Debug.Assert(!symbol.IsImplicitlyDeclared); OnSymbolActionCore(symbol, reportDiagnostic, isImplicitlyDeclaredConstructor: false, explicitLocation: explicitLocation); // Handle implicitly declared public constructors. if (symbol.Kind == SymbolKind.NamedType) { var namedType = (INamedTypeSymbol)symbol; if (namedType.InstanceConstructors.Length == 1 && (namedType.TypeKind == TypeKind.Class || namedType.TypeKind == TypeKind.Struct)) { var instanceConstructor = namedType.InstanceConstructors[0]; if (instanceConstructor.IsImplicitlyDeclared) { OnSymbolActionCore(instanceConstructor, reportDiagnostic, isImplicitlyDeclaredConstructor: true, explicitLocation: explicitLocation); } } } }
protected internal GeoEntity(IPAddress query, IPSubnetBlock block, Location?location) { Query = query; Block = block; Location = location; }
public DocumentNode WithLocation(Location? location) { return new DocumentNode(location, Definitions); }
public OperationTypeDefinitionNode WithLocation(Location?location) { return(new OperationTypeDefinitionNode( location, Operation, Type)); }
public EdgeLabel(string text) { this.text = text; this.location = null; }
public override BoundNode?VisitLocalFunctionStatement(BoundLocalFunctionStatement localFunc) { if (localFunc.Symbol.IsExtern) { // an extern local function is not permitted to have a body and thus shouldn't be flow analyzed return(null); } var oldSymbol = this.CurrentSymbol; var localFuncSymbol = localFunc.Symbol; this.CurrentSymbol = localFuncSymbol; var oldPending = SavePending(); // we do not support branches into a lambda // SPEC: The entry point to a local function is always reachable. // Captured variables are definitely assigned if they are definitely assigned on // all branches into the local function. var savedState = this.State; this.State = this.TopState(); Optional <TLocalState> savedNonMonotonicState = NonMonotonicState; if (_nonMonotonicTransfer) { NonMonotonicState = ReachableBottomState(); } if (!localFunc.WasCompilerGenerated) { EnterParameters(localFuncSymbol.Parameters); } // State changes to captured variables are recorded, as calls to local functions // transition the state of captured variables if the variables have state changes // across all branches leaving the local function var localFunctionState = GetOrCreateLocalFuncUsages(localFuncSymbol); var savedLocalFunctionState = LocalFunctionStart(localFunctionState); var oldPending2 = SavePending(); // If this is an iterator, there's an implicit branch before the first statement // of the function where the enumerable is returned. if (localFuncSymbol.IsIterator) { PendingBranches.Add(new PendingBranch(null, this.State, null)); } VisitAlways(localFunc.Body); RestorePending(oldPending2); // process any forward branches within the lambda body ImmutableArray <PendingBranch> pendingReturns = RemoveReturns(); RestorePending(oldPending); Location?location = null; if (!localFuncSymbol.Locations.IsDefaultOrEmpty) { location = localFuncSymbol.Locations[0]; } LeaveParameters(localFuncSymbol.Parameters, localFunc.Syntax, location); // Intersect the state of all branches out of the local function var stateAtReturn = this.State; foreach (PendingBranch pending in pendingReturns) { this.State = pending.State; BoundNode branch = pending.Branch; // Pass the local function identifier as a location if the branch // is null or compiler generated. LeaveParameters(localFuncSymbol.Parameters, branch?.Syntax, branch?.WasCompilerGenerated == false ? null : location); Join(ref stateAtReturn, ref this.State); } // Record any changes to the state of captured variables if (RecordStateChange( savedLocalFunctionState, localFunctionState, ref stateAtReturn) && localFunctionState.Visited) { // If the sets have changed and we already used the results // of this local function in another computation, the previous // calculations may be invalid. We need to analyze until we // reach a fixed-point. stateChangedAfterUse = true; localFunctionState.Visited = false; } this.State = savedState; NonMonotonicState = savedNonMonotonicState; this.CurrentSymbol = oldSymbol; return(null); }
public static void Log(this GeneratorExecutionContext context, string id, string message, DiagnosticSeverity severity = DiagnosticSeverity.Warning, Location?location = null) { location ??= Location.None; context.ReportDiagnostic( Diagnostic.Create( new DiagnosticDescriptor( id, message, message, "Shiny", severity, true ), location ) ); }
public ListTypeNode WithLocation(Location?location) { return(new ListTypeNode(location, Type)); }
protected internal GeoEntity(IPAddress query, IPSubnetBlock block, Location? location) { Query = query; Block = block; Location = location; }
private void Diag(DiagnosticDescriptor desc, Location?location, params object?[]?messageArgs) { _reportDiagnostic(Diagnostic.Create(desc, location, messageArgs)); }
public EnumTypeExtensionNode WithLocation(Location?location) { return(new EnumTypeExtensionNode( location, Name, Directives, Values)); }
private bool AnalyzeMemberWithinContext(ITypeSymbol type, ISymbol?symbol, SyntaxNodeAnalysisContext context, Location?focusDiagnosticOn = null) { if (type is null) { throw new ArgumentNullException(nameof(type)); } bool requiresUIThread = (type.TypeKind == TypeKind.Interface || type.TypeKind == TypeKind.Class) && this.MembersRequiringMainThread.Contains(type, symbol); if (requiresUIThread) { ThreadingContext threadingContext = ThreadingContext.Unknown; SyntaxNode? methodDeclaration = context.Node.FirstAncestorOrSelf <SyntaxNode>(n => CSharpCommonInterest.MethodSyntaxKinds.Contains(n.Kind())); if (methodDeclaration is object) { threadingContext = this.methodDeclarationNodes.GetValueOrDefault(methodDeclaration); } if (threadingContext != ThreadingContext.MainThread) { CSharpUtils.ContainingFunctionData function = CSharpUtils.GetContainingFunction((CSharpSyntaxNode)context.Node); Location location = focusDiagnosticOn ?? context.Node.GetLocation(); DiagnosticDescriptor?descriptor = function.IsAsync ? DescriptorAsync : DescriptorSync; var formattingArgs = function.IsAsync ? new object[] { type.Name } : new object[] { type.Name, this.MainThreadAssertingMethods.FirstOrDefault() }; context.ReportDiagnostic(Diagnostic.Create(descriptor, location, this.DiagnosticProperties, formattingArgs)); return(true); } } return(false); }
//--------------------------------------------------------------------- private void Initialize(IInputGrid<bool> activeSites) { this.firstActive = null; this.firstInactive = null; this.rowIntervals = new List<Interval>(); this.activeRows = new List<ActiveRow>(); this.columnIntervals = new List<Interval>(); bool inRowInterval = false; Interval rowInterval = new Interval(); for (uint row = 1; row <= activeSites.Rows; ++row) { uint colIntervalCount = 0; uint firstColIntervalIndex = 0; bool inColumnInterval = false; Interval columnInterval = new Interval(); for (uint column = 1; column <= activeSites.Columns; ++column) { if (activeSites.ReadValue()) { this.count++; if (! this.firstActive.HasValue) this.firstActive = new Location(row, column); if (inColumnInterval) { // extend column interval columnInterval.End = column; } else { // start a new column interval columnInterval = new Interval(column, column, count - 1); inColumnInterval = true; colIntervalCount++; if (colIntervalCount == 1) firstColIntervalIndex = (uint) columnIntervals.Count; } } else { // current site is inactive if (! this.firstInactive.HasValue) this.firstInactive = new Location(row, column); if (inColumnInterval) { // end of current column interval this.columnIntervals.Add(columnInterval); inColumnInterval = false; } } } // for each column // at end of current row if (colIntervalCount > 0) { // current row is an active row if (inColumnInterval) { // last column was active, so add its interval this.columnIntervals.Add(columnInterval); } this.activeRows.Add(new ActiveRow(colIntervalCount, firstColIntervalIndex)); if (inRowInterval) { // extend row interval rowInterval.End = row; } else { // start a new row interval rowInterval = new Interval(row, row, (uint)(activeRows.Count-1)); inRowInterval = true; } } else { // current row is not an active row if (inRowInterval) { this.rowIntervals.Add(rowInterval); inRowInterval = false; } } } // for each row if (inRowInterval) { // last row was an active row, so add its row interval this.rowIntervals.Add(rowInterval); } if (logger.IsDebugEnabled) { LogDebug("Active Site Map"); LogDebug(""); LogDebug("Input Grid: {0}", activeSites.Dimensions); LogDebug(""); LogDebug("Row Intervals"); LogDebug(" index: start to end (index of start row in active rows"); for (int i = 0; i < rowIntervals.Count; i++) { Interval interval = rowIntervals[i]; LogDebug(" {0}: {1} to {2} ({3})", i, interval.Start, interval.End, interval.StartOffset); } LogDebug(""); LogDebug("Active Rows"); LogDebug(" index: # column intervals, index of 1st column interval"); for (int i = 0; i < activeRows.Count; i++) { ActiveRow activeRow = ActiveRows[i]; LogDebug(" {0}: {1}, {2}", i, activeRow.IntervalCount, activeRow.FirstIntervalOffset); } LogDebug(""); LogDebug("Column Intervals"); LogDebug(" index: start to end (data index of start column"); for (int i = 0; i < columnIntervals.Count; i++) { Interval interval = columnIntervals[i]; LogDebug(" {0}: {1} to {2} ({3})", i, interval.Start, interval.End, interval.StartOffset); } } }
public EnumValueNode WithLocation(Location?location) { return(new EnumValueNode(location, Value)); }