/// <summary>
/// Get all posts. This is rate-limited to once every 60 seconds and will return a 429 error if you exceed that
/// </summary>
/// <param name="Tags"></param>
/// <param name="Start">Offset to start from - default is 0</param>
/// <param name="Results">Number of posts to return - default is all</param>
/// <param name="FromDate">Return only bookmarks created after this time</param>
/// <param name="ToDate">Return only bookmarks created before this time</param>
/// <param name="ChangedMeta">Include the "meta" attribute in the response</param>
/// <returns>A list of Posts</returns>
public async Task <IRestResponse <List <Post> > > GetAllPostsAsync(List <Tag> Tags = null, int?Start = null, int?Results = null, DateTime?FromDate = null, DateTime?ToDate = null, bool ChangedMeta = false)
{
RestRequest getPostsReq = new RestRequest("/posts/all");
getPostsReq.RequestFormat = DataFormat.Json;
if (Tags != null)
{
getPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("tag", Tags));
}
if (Start.HasValue)
{
getPostsReq.AddParameter("start", Start);
}
if (Results.HasValue)
{
getPostsReq.AddParameter("results", Results);
}
if (FromDate.HasValue)
{
getPostsReq.AddParameter("fromdt", FromDate);
}
if (ToDate.HasValue)
{
getPostsReq.AddParameter("todt", ToDate);
}
return(await ExecuteAsync <List <Post> >(getPostsReq));
}
private void ProcessDateFilter(Property property, DateTime?datetime)
{
if (datetime != null)
{
AddPipelineFilter(property, ParameterHelpers.DateToString(datetime.Value), false);
}
}
private DateTime?GetDateTime(Property property)
{
var val = GetFilterValue(property);
if (val == null)
{
return(null);
}
return(ParameterHelpers.StringToDate(val.ToString()));
}
public void TestValueToGet()
{
//var stringParam = ParameterHelpers.ValueToGetArgument("string", "string");
var boolParam = ParameterHelpers.ValueToGetArgument("didThisWork", true);
var dateTimeParam = ParameterHelpers.ValueToGetArgument("letsParty", new DateTime(1999, 12, 31));
var tags = new List <Tag>();
tags.Add(new Tag("something"));
tags.Add(new Tag("else"));
var tagParam = ParameterHelpers.ValueToGetArgument("tags", tags);
Assert.AreEqual(boolParam.ToString(), "didThisWork=yes");
Assert.AreEqual(dateTimeParam.ToString(), "letsParty=1999-12-31T00:00:00Z");
Assert.AreEqual(tagParam.ToString(), "tags=something else");
}
private static void MustBeInASaneOrder(SyntaxNodeAnalysisContext syntaxNodeAnalysisContext)
{
if (syntaxNodeAnalysisContext.Node is not ParameterListSyntax parameterList)
{
return;
}
var parameters = parameterList.Parameters.Select((parameter, index) => new
{
Parameter = parameter,
Index = index,
FullTypeName = ParameterHelpers.GetFullTypeName(
syntaxNodeAnalysisContext: syntaxNodeAnalysisContext,
parameterSyntax: parameter)
})
.ToArray();
List <string> matchedEndings = new();
foreach (string parameterType in PreferredEndingOrdering.Reverse())
{
var matchingParameter = Array.Find(array: parameters, match: x => x.FullTypeName == parameterType);
if (matchingParameter == null)
{
continue;
}
if (matchingParameter.Parameter.Modifiers.Any(pm => pm.IsKind(SyntaxKind.ThisKeyword)))
{
// Ignore parameters that are extension methods - they have to be the first parameter
continue;
}
matchedEndings.Add(parameterType);
int parameterIndex = matchingParameter.Index;
int requiredParameterIndex = parameters.Length - matchedEndings.Count;
if (parameterIndex != requiredParameterIndex)
{
syntaxNodeAnalysisContext.ReportDiagnostic(Diagnostic.Create(descriptor: Rule,
matchingParameter.Parameter.GetLocation(),
matchingParameter.Parameter.Identifier.Text,
requiredParameterIndex + 1));
}
}
}
private DateTime?GetDateTime(Property property)
{
var val = GetFilterValue(property);
if (val == null)
{
return(null);
}
if (val is DateTime)
{
return((DateTime?)val);
}
//We're retrieving a DateTime we serialized previously
return(ParameterHelpers.StringToDate(val.ToString()));
}
private void EnsureAttributesExist(TypeCompilationState compilationState)
{
var moduleBuilder = compilationState.ModuleBuilderOpt;
if (moduleBuilder is null)
{
return;
}
if (RefKind == RefKind.RefReadOnly)
{
moduleBuilder.EnsureIsReadOnlyAttributeExists();
}
ParameterHelpers.EnsureIsReadOnlyAttributeExists(moduleBuilder, Parameters);
if (moduleBuilder.Compilation.ShouldEmitNativeIntegerAttributes())
{
if (ReturnType.ContainsNativeIntegerWrapperType())
{
moduleBuilder.EnsureNativeIntegerAttributeExists();
}
ParameterHelpers.EnsureNativeIntegerAttributeExists(moduleBuilder, Parameters);
}
ParameterHelpers.EnsureLifetimeAnnotationAttributeExists(moduleBuilder, Parameters);
if (compilationState.Compilation.ShouldEmitNullableAttributes(this))
{
if (ShouldEmitNullableContextValue(out _))
{
moduleBuilder.EnsureNullableContextAttributeExists();
}
if (ReturnTypeWithAnnotations.NeedsNullableAttribute())
{
moduleBuilder.EnsureNullableAttributeExists();
}
}
ParameterHelpers.EnsureNullableAttributeExists(moduleBuilder, this, Parameters);
}
/// <summary>
/// Get posts - filtered by URL, tags or date
/// </summary>
/// <param name="Tags">A list of up to 3 tags</param>
/// <param name="CreatedDate">Return posts created on this date</param>
/// <param name="URL">Return the post with this URL</param>
/// <param name="ChangedMeta">Include the "meta" attribute in the response</param>
/// <returns>A list of Post objects</returns>
public async Task <IRestResponse <List <Post> > > GetPostsAsync(List <Tag> Tags = null, DateTime?CreatedDate = null, string URL = null, bool ChangedMeta = false)
{
RestRequest GetPostsReq = new RestRequest("/posts/get");
if (Tags != null)
{
GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("tags", Tags));
}
if (CreatedDate.HasValue)
{
GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("dt", CreatedDate.Value));
}
if (URL != null)
{
GetPostsReq.AddParameter("url", URL);
}
GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("meta", ChangedMeta));
return(await ExecuteAsync <List <Post> >(GetPostsReq));
}
protected override ReadOnlyArray <ParameterSymbol> MakeParameters(
Binder binder,
DelegateDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
SyntaxToken extensionMethodThis;
SyntaxToken arglistToken;
var parameters = ParameterHelpers.MakeParameters(binder, this, syntax.ParameterList, true, out extensionMethodThis, out arglistToken, diagnostics);
if (arglistToken.Kind == SyntaxKind.ArgListKeyword)
{
// This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn.
// error CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken));
}
return(parameters);
}
public void SystemInfo_Software_PropertiesMapCorrectly()
{
var name = "\"Name\"";
var vendor = "\"Vendor\"";
var version = "1.2";
var date = "\"2017-05-23-00-00-00\"";
var size = "1234";
var displayName = "\"DisplayName\"";
var obj = GetSystemInfoResponse <DeviceSoftwareInfo>(
SystemInfoItem.SoftwareItem(name, vendor, version, date, size, displayName)
);
AssertAreEqual(name, obj.Name);
AssertAreEqual(vendor, obj.Vendor);
AssertAreEqual(Version.Parse(version), obj.Version);
AssertAreEqual(ParameterHelpers.StringToDate(date.Trim('"')), obj.InstallDate);
AssertAreEqual(Convert.ToInt32(size), obj.Size);
AssertAreEqual(displayName, obj.DisplayName);
}
/// <summary>
/// Adds a post based on the querystring we pass
/// </summary>
/// <param name="newPost">The post to add</param>
/// <returns>PinboardResponse</returns>
public async Task <IRestResponse <PinboardResponse> > AddPostAsync(Post newPost)
{
RestRequest AddPostRequest = new RestRequest("/posts/add");
if (newPost.Href != null)
{
AddPostRequest.AddParameter("url", newPost.Href);
}
if (newPost.Description != null)
{
AddPostRequest.AddParameter("description", newPost.Description);
}
if (newPost.Extended != null)
{
AddPostRequest.AddParameter("extended", newPost.Extended);
}
if (newPost.Tag != null)
{
AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("tags", newPost.Tag));
}
if (newPost.CreationTime.HasValue)
{
AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("dt", newPost.CreationTime));
}
if (newPost.Replace != null)
{
AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("replace", newPost.Replace));
}
if (newPost.Shared != null)
{
AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("shared", newPost.Shared));
}
if (newPost.ToRead != null)
{
AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("toread", newPost.ToRead));
}
return(await ExecuteAsync <PinboardResponse>(AddPostRequest));
}
// 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 UnboundLambda AnalyzeAnonymousFunction(
AnonymousFunctionExpressionSyntax syntax, BindingDiagnosticBag diagnostics)
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.IsAnonymousFunction());
ImmutableArray <string> names = default;
ImmutableArray <RefKind> refKinds = default;
ImmutableArray <DeclarationScope> scopes = default;
ImmutableArray <TypeWithAnnotations> types = default;
RefKind returnRefKind = RefKind.None;
TypeWithAnnotations returnType = default;
ImmutableArray <SyntaxList <AttributeListSyntax> > parameterAttributes = default;
var namesBuilder = ArrayBuilder <string> .GetInstance();
ImmutableArray <bool> discardsOpt = default;
SeparatedSyntaxList <ParameterSyntax>?parameterSyntaxList = null;
bool hasSignature;
if (syntax is LambdaExpressionSyntax lambdaSyntax)
{
checkAttributes(syntax, lambdaSyntax.AttributeLists, diagnostics);
}
switch (syntax.Kind())
{
default:
case SyntaxKind.SimpleLambdaExpression:
// x => ...
hasSignature = true;
var simple = (SimpleLambdaExpressionSyntax)syntax;
namesBuilder.Add(simple.Parameter.Identifier.ValueText);
break;
case SyntaxKind.ParenthesizedLambdaExpression:
// (T x, U y) => ...
// (x, y) => ...
hasSignature = true;
var paren = (ParenthesizedLambdaExpressionSyntax)syntax;
if (paren.ReturnType is { } returnTypeSyntax)
{
(returnRefKind, returnType) = BindExplicitLambdaReturnType(returnTypeSyntax, diagnostics);
}
parameterSyntaxList = paren.ParameterList.Parameters;
CheckParenthesizedLambdaParameters(parameterSyntaxList.Value, diagnostics);
break;
case SyntaxKind.AnonymousMethodExpression:
// delegate (int x) { }
// delegate { }
var anon = (AnonymousMethodExpressionSyntax)syntax;
hasSignature = anon.ParameterList != null;
if (hasSignature)
{
parameterSyntaxList = anon.ParameterList !.Parameters;
}
break;
}
var isAsync = syntax.Modifiers.Any(SyntaxKind.AsyncKeyword);
var isStatic = syntax.Modifiers.Any(SyntaxKind.StaticKeyword);
if (parameterSyntaxList != null)
{
var hasExplicitlyTypedParameterList = true;
var typesBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance();
var refKindsBuilder = ArrayBuilder <RefKind> .GetInstance();
var scopesBuilder = ArrayBuilder <DeclarationScope> .GetInstance();
var attributesBuilder = ArrayBuilder <SyntaxList <AttributeListSyntax> > .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.
int underscoresCount = 0;
foreach (var p in parameterSyntaxList.Value)
{
if (p.Identifier.IsUnderscoreToken())
{
underscoresCount++;
}
checkAttributes(syntax, p.AttributeLists, diagnostics);
if (p.Default != null)
{
Error(diagnostics, ErrorCode.ERR_DefaultValueNotAllowed, p.Default.EqualsToken);
}
if (p.IsArgList)
{
Error(diagnostics, ErrorCode.ERR_IllegalVarArgs, p);
continue;
}
var typeSyntax = p.Type;
TypeWithAnnotations type = default;
var refKind = RefKind.None;
var scope = DeclarationScope.Unscoped;
if (typeSyntax == null)
{
hasExplicitlyTypedParameterList = false;
}
else
{
type = BindType(typeSyntax, diagnostics);
ParameterHelpers.CheckParameterModifiers(p, diagnostics, parsingFunctionPointerParams: false, parsingLambdaParams: true);
refKind = ParameterHelpers.GetModifiers(p.Modifiers, out _, out _, out _, out scope);
}
namesBuilder.Add(p.Identifier.ValueText);
typesBuilder.Add(type);
refKindsBuilder.Add(refKind);
scopesBuilder.Add(scope);
attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default);
private BoundLambda ReallyBind(NamedTypeSymbol delegateType)
{
var invokeMethod = DelegateInvokeMethod(delegateType);
RefKind refKind;
var returnType = DelegateReturnType(invokeMethod, out refKind);
LambdaSymbol lambdaSymbol;
Binder lambdaBodyBinder;
BoundBlock block;
var diagnostics = DiagnosticBag.GetInstance();
// when binding for real (not for return inference), there is still
// a good chance that we could reuse a body of a lambda previously bound for
// return type inference.
var cacheKey = ReturnInferenceCacheKey.Create(delegateType, IsAsync);
BoundLambda returnInferenceLambda;
if (_returnInferenceCache.TryGetValue(cacheKey, out returnInferenceLambda) && returnInferenceLambda.InferredFromSingleType)
{
lambdaSymbol = returnInferenceLambda.Symbol;
if ((object)LambdaSymbol.InferenceFailureReturnType != lambdaSymbol.ReturnType &&
lambdaSymbol.ReturnType == returnType && lambdaSymbol.RefKind == refKind)
{
lambdaBodyBinder = returnInferenceLambda.Binder;
block = returnInferenceLambda.Body;
diagnostics.AddRange(returnInferenceLambda.Diagnostics);
goto haveLambdaBodyAndBinders;
}
}
lambdaSymbol = new LambdaSymbol(
binder.Compilation,
binder.ContainingMemberOrLambda,
_unboundLambda,
cacheKey.ParameterTypes,
cacheKey.ParameterRefKinds,
refKind,
returnType,
diagnostics);
lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, ParameterBinder(lambdaSymbol, binder));
if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly)
{
binder.Compilation.EnsureIsReadOnlyAttributeExists(diagnostics, lambdaSymbol.DiagnosticLocation, modifyCompilationForRefReadOnly: false);
}
ParameterHelpers.EnsureIsReadOnlyAttributeExists(lambdaSymbol.Parameters, diagnostics, modifyCompilationForRefReadOnly: false);
block = BindLambdaBody(lambdaSymbol, lambdaBodyBinder, diagnostics);
((ExecutableCodeBinder)lambdaBodyBinder).ValidateIteratorMethods(diagnostics);
ValidateUnsafeParameters(diagnostics, cacheKey.ParameterTypes);
haveLambdaBodyAndBinders:
bool reachableEndpoint = ControlFlowPass.Analyze(binder.Compilation, lambdaSymbol, block, diagnostics);
if (reachableEndpoint)
{
if (DelegateNeedsReturn(invokeMethod))
{
// Not all code paths return a value in {0} of type '{1}'
diagnostics.Add(ErrorCode.ERR_AnonymousReturnExpected, lambdaSymbol.DiagnosticLocation, this.MessageID.Localize(), delegateType);
}
else
{
block = FlowAnalysisPass.AppendImplicitReturn(block, lambdaSymbol);
}
}
if (IsAsync && !ErrorFacts.PreventsSuccessfulDelegateConversion(diagnostics))
{
if ((object)returnType != null && // Can be null if "delegateType" is not actually a delegate type.
returnType.SpecialType != SpecialType.System_Void &&
!returnType.IsNonGenericTaskType(binder.Compilation) &&
!returnType.IsGenericTaskType(binder.Compilation))
{
// Cannot convert async {0} to delegate type '{1}'. An async {0} may return void, Task or Task<T>, none of which are convertible to '{1}'.
diagnostics.Add(ErrorCode.ERR_CantConvAsyncAnonFuncReturns, lambdaSymbol.DiagnosticLocation, lambdaSymbol.MessageID.Localize(), delegateType);
}
}
if (IsAsync)
{
Debug.Assert(lambdaSymbol.IsAsync);
SourceOrdinaryMethodSymbol.ReportAsyncParameterErrors(lambdaSymbol.Parameters, diagnostics, lambdaSymbol.DiagnosticLocation);
}
var result = new BoundLambda(_unboundLambda.Syntax, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferReturnType: false)
{
WasCompilerGenerated = _unboundLambda.WasCompilerGenerated
};
return(result);
}
protected string LogDate(DateTime date)
{
return(ParameterHelpers.DateToString(date));
}
private static string GetTime(DateTime dateTime)
{
return(ParameterHelpers.DateToString(dateTime));
}
private DateTime GetDate(Parameter parameter)
{
return(ParameterHelpers.StringToDate(this[parameter].ToString()));
}
private void SetDate(Parameter parameter, DateTime value)
{
this[parameter] = ParameterHelpers.DateToString(value);
}
private void SetDateTime(Property property, DateTime?value)
{
SetFilterValue(property, value == null ? null : ParameterHelpers.DateToString(value.Value));
}
internal virtual DateTime FormatDate(string value)
{
return(ParameterHelpers.StringToDate(value));
}
