protected override void Update(CommandArrayInfo info) { ResolverContextStack ctxt; var rr = Resolver.DResolverWrapper.ResolveHoveredCode(out ctxt); bool noRes = true; if (rr != null && rr.Length > 0) { res = rr[rr.Length - 1]; n = DResolver.GetResultMember(res); if (n != null) { noRes = false; info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.GotoDeclaration), new Action(GotoDeclaration)); info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.FindReferences), new Action(FindReferences)); if (RenamingRefactoring.CanRename(n)) { info.AddSeparator(); info.Add(IdeApp.CommandService.GetCommandInfo(EditCommands.Rename), new Action(RenameSymbol)); } } } if(noRes) info.Add(IdeApp.CommandService.GetCommandInfo(RefactoryCommands.ImportSymbol), new Action(ImportSymbol)); info.Add(IdeApp.CommandService.GetCommandInfo(Commands.OpenDDocumentation), new Action(OpenDDoc)); }
public string GenTooltipSignature(AbstractType t, bool templateParamCompletion = false, int currentMethodParam = -1) { var ds = t as DSymbol; if (ds != null) { if (currentMethodParam >= 0 && !templateParamCompletion && ds.Definition is DVariable && ds.Base != null) return GenTooltipSignature(ds.Base, false, currentMethodParam); var aliasedSymbol = ds.Tag<TypeDeclarationResolver.AliasTag>(TypeDeclarationResolver.AliasTag.Id); return GenTooltipSignature(aliasedSymbol == null || currentMethodParam >= 0 ? ds.Definition : aliasedSymbol.aliasDefinition, templateParamCompletion, currentMethodParam, DTypeToTypeDeclVisitor.GenerateTypeDecl(ds.Base), new DeducedTypeDictionary(ds)); } if (t is PackageSymbol) { var pack = (t as PackageSymbol).Package; return "<i>(Package)</i> " + pack.ToString(); } if (t is DelegateType) { var sb = new StringBuilder(); GenDelegateSignature(t as DelegateType, sb, templateParamCompletion, currentMethodParam); return sb.ToString(); } return DCodeToMarkup(t != null ? t.ToCode(true) : "null"); }
public static string GenerateCode(AbstractType t, bool pretty = false) { var vis = new DTypeToCodeVisitor(pretty); vis.AcceptType(t); return vis.sb.ToString(); }
public static string GenerateCode(AbstractType t) { var vis = new DTypeToCodeVisitor(); vis.AcceptType(t); return vis.sb.ToString(); }
public ObjectCacheNode(string n, AbstractType t, ulong address) { if(string.IsNullOrEmpty(n)) throw new ArgumentNullException("name","Child name must not be empty!"); if(t == null) throw new ArgumentNullException("t","Abstract type of '"+n+"' must not be null!"); Name = n; NodeType = t; this.address = address; }
public ObjectCacheNode(string n, AbstractType t, string exp) { if(string.IsNullOrEmpty(n)) throw new ArgumentNullException("name","Child name must not be empty!"); if(t == null) throw new ArgumentNullException("t","Abstract type of '"+n+"' must not be null!"); if(string.IsNullOrEmpty(exp)) throw new ArgumentNullException("exp","Address expression must not be empty!"); Name = n; NodeType = t; addressExpression = exp; }
public DNode GenerateRepresentativeNode(AbstractType t, ResolutionContext ctxt) { if (NodeGetter != null) return NodeGetter(t, ctxt); return new DVariable() { Attributes = !RequireThis ? StaticAttributeList : null, Name = Name, Description = Description, Type = GetPropertyType(t, ctxt) }; }
//TODO: Für semantisches Highlighting den TypeRefFinder benutzen und einfach pauschal alle Ids entsprechend highlighten public static TooltipInformation Create(AbstractType t, ColorScheme st, bool templateParamCompletion = false, int currentMethodParam = -1) { var markupGen = new TooltipMarkupGen (st); var tti = new TooltipInformation { SignatureMarkup = markupGen.GenTooltipSignature (t, templateParamCompletion, currentMethodParam) }; var ds = t as DSymbol; DNode n; if (ds != null && (n = ds.Definition) != null) CreateTooltipBody (markupGen, n, tti); return tti; }
protected DSymbol(DNode Node, AbstractType BaseType, IEnumerable <TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(BaseType, td) { if (deducedTypes != null) { this.DeducedTypes = new ReadOnlyCollection <TemplateParameterSymbol>(deducedTypes.ToList()); } if (Node == null) { throw new ArgumentNullException("Node"); } this.definition = new WeakReference(Node); NameHash = Node.NameHash; }
public string GenTooltipSignature(AbstractType t, bool templateParamCompletion = false, int currentMethodParam = -1) { var ds = t as DSymbol; if (ds != null) { var aliasedSymbol = ds.Tag as D_Parser.Resolver.TypeResolution.TypeDeclarationResolver.AliasTag; return GenTooltipSignature(aliasedSymbol == null ? ds.Definition : aliasedSymbol.aliasDefinition, templateParamCompletion, currentMethodParam, DTypeToTypeDeclVisitor.GenerateTypeDecl(ds.Base), ds.DeducedTypes != null ? new DeducedTypeDictionary(ds) : null); } if (t is PackageSymbol) { var pack = (t as PackageSymbol).Package; return "<i>(Package)</i> "+pack.ToString(); } return DCodeToMarkup (t != null ? t.ToCode () : "null"); }
void GenUfcsAndStaticProperties(AbstractType t) { if (t.NonStaticAccess && CompletionOptions.Instance.ShowUFCSItems) CodeCompletion.DoTimeoutableCompletionTask(null, ctxt, () => { try { foreach (var ufcsItem in UFCSResolver.TryResolveUFCS(t, 0, ed.CaretLocation, ctxt)) CompletionDataGenerator.Add((ufcsItem as DSymbol).Definition); } catch(Exception ex) { Logger.LogWarn("Error during ufcs completion resolution", ex); } }); StaticProperties.ListProperties(CompletionDataGenerator, ctxt, MemberFilter, t, t.NonStaticAccess); }
public DelegateType(AbstractType ReturnType, DelegateDeclaration Declaration, IEnumerable <AbstractType> Parameters = null) : base(ReturnType, Declaration) { this.IsFunction = Declaration.IsFunction; if (ReturnType != null) { ReturnType.NonStaticAccess = true; } if (Parameters is AbstractType[]) { this.Parameters = (AbstractType[])Parameters; } else if (Parameters != null) { this.Parameters = Parameters.ToArray(); } }
public DelegateType(AbstractType ReturnType, FunctionLiteral Literal, IEnumerable <AbstractType> Parameters) : base(ReturnType, Literal) { this.IsFunction = Literal.LiteralToken == DTokens.Function; if (ReturnType != null) { ReturnType.NonStaticAccess = true; } if (Parameters is AbstractType[]) { this.Parameters = (AbstractType[])Parameters; } else if (Parameters != null) { this.Parameters = Parameters.ToArray(); } }
public static TooltipInformation Generate(AbstractType t, int currentParameter = -1, bool isInTemplateArgInsight = false) { var ms = t as MemberSymbol; if (ms != null) { if (ms.Definition is DVariable) { var bt = DResolver.StripAliasSymbol(ms.Base); if (bt is DelegateType) return TooltipInfoGenerator.Generate(bt as DelegateType, currentParameter); } else if (ms.Definition is DMethod) return TooltipInfoGenerator.Generate(ms.Definition as DMethod, isInTemplateArgInsight, currentParameter); } else if (t is TemplateIntermediateType) return Generate(t as TemplateIntermediateType, currentParameter); return new TooltipInformation(); }
/// <summary> /// returns float/double/creal when cfloat/cdouble/creal are given /// </summary> /// <returns>The reflect non complex type.</returns> /// <param name="t">T.</param> /// <param name="ctxt">Ctxt.</param> static ITypeDeclaration help_ReflectNonComplexType(AbstractType t, ResolutionContext ctxt) { var pt = t as PrimitiveType; if (pt != null) { switch (pt.TypeToken) { case DTokens.Cfloat: return(new DTokenDeclaration(DTokens.Float)); case DTokens.Cdouble: return(new DTokenDeclaration(DTokens.Double)); case DTokens.Creal: return(new DTokenDeclaration(DTokens.Real)); } } return(DTypeToTypeDeclVisitor.GenerateTypeDecl(t)); }
static AbstractType help_ReflectResolvedNonComplexType(AbstractType t, ResolutionContext ctxt) { var pt = t as PrimitiveType; if (pt != null) { switch (pt.TypeToken) { case DTokens.Cfloat: return(new PrimitiveType(DTokens.Float)); case DTokens.Cdouble: return(new PrimitiveType(DTokens.Double)); case DTokens.Creal: return(new PrimitiveType(DTokens.Real)); } } return(t); }
void AcceptType(AbstractType t) { if (t == null) return; if (pretty) { var aliasTag = t.Tag<TypeDeclarationResolver.AliasTag>(TypeDeclarationResolver.AliasTag.Id); if (aliasTag != null) sb.Append(aliasTag.typeBase != null ? aliasTag.typeBase.ToString() : aliasTag.aliasDefinition.ToString(false, false)).Append('='); } if (t.Modifier != 0) sb.Append(DTokens.GetTokenString(t.Modifier)).Append('('); t.Accept(this); if (t.Modifier != 0) sb.Append(')'); }
public static StaticProperty TryEvalPropertyType(ResolutionContext ctxt, AbstractType t, int propName, bool staticOnly = false) { GetLookedUpType(ref t); if (t == null) { return(null); } var props = Properties[PropOwnerType.Generic]; StaticPropertyInfo prop; if (props.TryGetValue(propName, out prop) || (Properties.TryGetValue(GetOwnerType(t), out props) && props.TryGetValue(propName, out prop))) { var n = prop.GenerateRepresentativeNode(t); return(new StaticProperty(n, n.Type != null ? TypeDeclarationResolver.ResolveSingle(n.Type, ctxt) : null, prop.ValueGetter)); } return(null); }
public static string GetReferenceUrl(AbstractType result, ResolutionContext ctxt, CodeLocation caret) { if (result != null) { var n = DResolver.GetResultMember (result); if (n != null && n.NodeRoot is DModule) { if (IsPhobosModule (n.NodeRoot as DModule)) { var phobos_url = "phobos/" + (n.NodeRoot as DModule).ModuleName.Replace ('.', '_') + ".html"; if (!(n is DModule)) phobos_url += "#" + n.Name; return phobos_url; } } else if (result is PrimitiveType || result is DelegateType || result is AssocArrayType) { if (result.DeclarationOrExpressionBase is ITypeDeclaration) return GetRefUrlFor ((ITypeDeclaration)result.DeclarationOrExpressionBase); else if (result.DeclarationOrExpressionBase is IExpression) return GetRefUrlFor ((IExpression)result.DeclarationOrExpressionBase); } } if (ctxt.ScopedStatement != null) { return GetRefUrlFor (ctxt.ScopedStatement, caret); } else if (ctxt.ScopedBlock is DClassLike) { var dc = ctxt.ScopedBlock as DClassLike; if (dc.ClassType == DTokens.Class) return "class.html"; else if (dc.ClassType == DTokens.Interface) return "interface.html"; else if (dc.ClassType == DTokens.Struct || dc.ClassType == DTokens.Union) return "struct.html"; else if (dc.ClassType == DTokens.Template) return "template.html"; } else if (ctxt.ScopedBlock is DEnum) return "enum.html"; return null; }
static void GetLookedUpType(ref AbstractType t) { while (t is AliasedType || t is PointerType) { t = (t as DerivedDataType).Base; } var tps = t as TemplateParameterSymbol; if (tps != null && tps.Base == null && (tps.Parameter is TemplateThisParameter ? (tps.Parameter as TemplateThisParameter).FollowParameter : tps.Parameter) is TemplateTupleParameter) { return; } else { t = DResolver.StripMemberSymbols(t); } while (t is AliasedType || t is PointerType) { t = (t as DerivedDataType).Base; } }
public PointerType(AbstractType Base, ISyntaxRegion td) : base(Base, td) { }
public DSymbol(DNode Node, AbstractType BaseType, IEnumerable<TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(BaseType, td) { if(deducedTypes!=null) this.DeducedTypes = new ReadOnlyCollection<TemplateParameterSymbol>(deducedTypes.ToArray()); if (Node == null) throw new ArgumentNullException ("Node"); this.definition = new WeakReference(Node); NameHash = Node.NameHash; }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null) : base(member, memberType, deducedTypes, td) { }
public AssocArrayType(AbstractType ValueType, AbstractType KeyType, ISyntaxRegion td) : base(ValueType, td) { this.KeyType = KeyType; }
public DelegateType(AbstractType ReturnType, FunctionLiteral Literal, IEnumerable<AbstractType> Parameters) : base(ReturnType, Literal) { this.IsFunction = Literal.LiteralToken == DTokens.Function; if (Parameters is AbstractType[]) this.Parameters = (AbstractType[])Parameters; else if (Parameters != null) this.Parameters = Parameters.ToArray(); }
protected UserDefinedType(DNode Node, AbstractType baseType, ReadOnlyCollection <TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(Node, baseType, deducedTypes, td) { }
public StaticProperty(DNode n, AbstractType bt, StaticProperties.ValueGetterHandler valueGetter) : base(n, bt, null) { this.n = n; this.ValueGetter = valueGetter; }
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td, AbstractType baseType = null, InterfaceType[] baseInterfaces = null, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null) : base(dc, baseType, deducedTypes, td) { this.BaseInterfaces = baseInterfaces; }
AbstractType Type(char type = '\0') { if(type == '\0') type = (char)r.Read(); switch(type) { case 'O': var t = Type(); t.Modifier = DTokens.Shared; return t; case 'x': t = Type(); t.Modifier = DTokens.Const; return t; case 'y': t = Type(); t.Modifier = DTokens.Immutable; return t; case 'N': switch(r.Read()) { case 'g': t = Type(); t.Modifier = DTokens.InOut; return t; case 'e': // TypeNewArray ? Type(); return null; } break; case 'A': return new ArrayType(Type()); case 'G': var len = (int)Number(); return new ArrayType(Type(), len); case 'H': var keyType = Type(); t = Type(); return new AssocArrayType(t, keyType); case 'P': return new PointerType(Type()); case 'F': case 'U': case 'W': case 'V': case 'R': AbstractType ret; List<DAttribute> attrs; Dictionary<INode,AbstractType> pars; Function(out ret, out attrs, out pars, type); var dm = new DMethod(){ Parameters = pars.Keys.ToList(), Attributes = attrs }; return new MemberSymbol(dm, ret, null); case 'C': case 'S': case 'E': case 'T': case 'I': return TypeDeclarationResolver.ResolveSingle (QualifiedName (), ctxt); /* return new MemberSymbol(null,null, QualifiedName()); case 'C': return new ClassType(new DClassLike(DTokens.Class), QualifiedName(), null); case 'S': return new StructType(new DClassLike(DTokens.Struct), QualifiedName()); case 'E': return new EnumType(new DEnum(), null, QualifiedName()); case 'T': return new AliasedType(null, null, QualifiedName()); */case 'D': Function(out ret, out attrs, out pars, type); var dgArgs = new List<AbstractType>(); foreach(var kv in pars) dgArgs.Add(new MemberSymbol(kv.Key as DNode, kv.Value, null)); return new DelegateType(ret,new DelegateDeclaration{ Parameters = pars.Keys.ToList() }, dgArgs); case 'v': return new PrimitiveType(DTokens.Void); case 'g': return new PrimitiveType(DTokens.Byte); case 'h': return new PrimitiveType(DTokens.Ubyte); case 's': return new PrimitiveType(DTokens.Short); case 't': return new PrimitiveType(DTokens.Ushort); case 'i': return new PrimitiveType(DTokens.Int); case 'k': return new PrimitiveType(DTokens.Uint); case 'l': return new PrimitiveType(DTokens.Long); case 'm': return new PrimitiveType(DTokens.Ulong); case 'f': return new PrimitiveType(DTokens.Float); case 'd': return new PrimitiveType(DTokens.Double); case 'e': return new PrimitiveType(DTokens.Real); case 'o': return new PrimitiveType(DTokens.Ifloat); case 'p': return new PrimitiveType(DTokens.Idouble); case 'j': return new PrimitiveType(DTokens.Ireal); case 'q': return new PrimitiveType(DTokens.Cfloat); case 'r': return new PrimitiveType(DTokens.Cdouble); case 'c': return new PrimitiveType(DTokens.Creal); case 'b': return new PrimitiveType(DTokens.Bool); case 'a': return new PrimitiveType(DTokens.Char); case 'u': return new PrimitiveType(DTokens.Wchar); case 'w': return new PrimitiveType(DTokens.Dchar); case 'n': return null; case 'B': len = (int)Number(); var items = new AbstractType[len]; var c = (char)r.Read(); for (int i = 0; i < len; i++) { Argument(ref c, out items[i]); } return new DTuple(items); } return null; }
public ITypeDeclaration GetPropertyType(AbstractType t) { return(OverrideType ?? (TypeGetter != null && t != null ? TypeGetter(t) : null)); }
public static void ListProperties(ICompletionDataGenerator gen, MemberFilter vis, AbstractType t, bool isVariableInstance) { foreach (var n in ListProperties(t, !isVariableInstance)) { if (AbstractVisitor.CanAddMemberOfType(vis, n)) { gen.Add(n); } } }
static ITypeDeclaration help_ReflectType(AbstractType t) { return(t.TypeDeclarationOf); }
public ITypeDeclaration GetPropertyType(AbstractType t, ResolutionContext ctxt) { return(OverrideType ?? (TypeGetter != null && t != null ? TypeGetter(t, ctxt) : null)); }
static StaticProperties() { var props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.Generic] = props; props.AddProp(new StaticPropertyInfo("init", "A type's or variable's static initializer expression") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props.AddProp(new StaticPropertyInfo("sizeof", "Size of a type or variable in bytes", DTokens.Uint)); // Do not define it as size_t due to unnecessary recursive definition as typeof(int.sizeof) props.AddProp(new StaticPropertyInfo("alignof", "Variable offset", DTokens.Uint) { RequireThis = true }); props.AddProp(new StaticPropertyInfo("mangleof", "String representing the ‘mangled’ representation of the type", "string")); props.AddProp(new StaticPropertyInfo("stringof", "String representing the source representation of the type", "string") { ValueGetter = (vp, v) => { var t = AbstractType.Get(v); if (t == null) { return(new NullValue()); } return(new ArrayValue(Evaluation.GetStringType(vp.ResolutionContext), (t is DSymbol) ? DNode.GetNodePath((t as DSymbol).Definition, true) : t.ToCode())); } }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.Integral] = props; props.AddProp(new StaticPropertyInfo("max", "Maximum value") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props.AddProp(new StaticPropertyInfo("min", "Minimum value") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.FloatingPoint] = props; props.AddProp(new StaticPropertyInfo("infinity", "Infinity value") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props.AddProp(new StaticPropertyInfo("nan", "Not-a-Number value") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props.AddProp(new StaticPropertyInfo("dig", "Number of decimal digits of precision", DTokens.Int)); props.AddProp(new StaticPropertyInfo("epsilon", "Smallest increment to the value 1") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType }); props.AddProp(new StaticPropertyInfo("mant_dig", "Number of bits in mantissa", DTokens.Int)); props.AddProp(new StaticPropertyInfo("max_10_exp", "Maximum int value such that 10^max_10_exp is representable", DTokens.Int)); props.AddProp(new StaticPropertyInfo("max_exp", "Maximum int value such that 2^max_exp-1 is representable", DTokens.Int)); props.AddProp(new StaticPropertyInfo("min_10_exp", "Minimum int value such that 10^max_10_exp is representable", DTokens.Int)); props.AddProp(new StaticPropertyInfo("min_exp", "Minimum int value such that 2^max_exp-1 is representable", DTokens.Int)); props.AddProp(new StaticPropertyInfo("min_normal", "Number of decimal digits of precision", DTokens.Int)); props.AddProp(new StaticPropertyInfo("re", "Real part") { TypeGetter = help_ReflectNonComplexType, ResolvedBaseTypeGetter = help_ReflectResolvedNonComplexType, RequireThis = true }); props.AddProp(new StaticPropertyInfo("im", "Imaginary part") { TypeGetter = help_ReflectNonComplexType, ResolvedBaseTypeGetter = help_ReflectResolvedNonComplexType, RequireThis = true }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.Array] = props; props.AddProp(new StaticPropertyInfo("length", "Array length", DTokens.Int) { RequireThis = true, ValueGetter = (vp, v) => { var av = v as ArrayValue; return(new PrimitiveValue(DTokens.Int, av.Elements != null ? av.Elements.Length : 0, null, 0m)); } }); props.AddProp(new StaticPropertyInfo("dup", "Create a dynamic array of the same size and copy the contents of the array into it.") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType, RequireThis = true }); props.AddProp(new StaticPropertyInfo("idup", "D2.0 only! Creates immutable copy of the array") { TypeGetter = (t, ctxt) => new MemberFunctionAttributeDecl(DTokens.Immutable) { InnerType = help_ReflectType(t, ctxt) }, RequireThis = true }); props.AddProp(new StaticPropertyInfo("reverse", "Reverses in place the order of the elements in the array. Returns the array.") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType, RequireThis = true }); props.AddProp(new StaticPropertyInfo("sort", "Sorts in place the order of the elements in the array. Returns the array.") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType, RequireThis = true }); props.AddProp(new StaticPropertyInfo("ptr", "Returns pointer to the array") { ResolvedBaseTypeGetter = (t, ctxt) => new PointerType((t as DerivedDataType).Base, t.DeclarationOrExpressionBase), TypeGetter = (t, ctxt) => new PointerDecl(DTypeToTypeDeclVisitor.GenerateTypeDecl((t as DerivedDataType).Base)), RequireThis = true }); props = new Dictionary <int, StaticPropertyInfo>(props); // Copy from arrays' properties! Properties[PropOwnerType.AssocArray] = props; props.AddProp(new StaticPropertyInfo("length", "Returns number of values in the associative array. Unlike for dynamic arrays, it is read-only.", "size_t") { RequireThis = true }); props.AddProp(new StaticPropertyInfo("keys", "Returns dynamic array, the elements of which are the keys in the associative array.") { TypeGetter = (t, ctxt) => new ArrayDecl { ValueType = DTypeToTypeDeclVisitor.GenerateTypeDecl((t as AssocArrayType).KeyType) }, RequireThis = true }); props.AddProp(new StaticPropertyInfo("values", "Returns dynamic array, the elements of which are the values in the associative array.") { TypeGetter = (t, ctxt) => new ArrayDecl { ValueType = DTypeToTypeDeclVisitor.GenerateTypeDecl((t as AssocArrayType).ValueType) }, RequireThis = true }); props.AddProp(new StaticPropertyInfo("rehash", "Reorganizes the associative array in place so that lookups are more efficient. rehash is effective when, for example, the program is done loading up a symbol table and now needs fast lookups in it. Returns a reference to the reorganized array.") { TypeGetter = help_ReflectType, ResolvedBaseTypeGetter = help_ReflectResolvedType, RequireThis = true }); props.AddProp(new StaticPropertyInfo("byKey", "Returns a delegate suitable for use as an Aggregate to a ForeachStatement which will iterate over the keys of the associative array.") { TypeGetter = (t, ctxt) => new DelegateDeclaration() { ReturnType = new ArrayDecl() { ValueType = DTypeToTypeDeclVisitor.GenerateTypeDecl((t as AssocArrayType).KeyType) } }, RequireThis = true }); props.AddProp(new StaticPropertyInfo("byValue", "Returns a delegate suitable for use as an Aggregate to a ForeachStatement which will iterate over the values of the associative array.") { TypeGetter = (t, ctxt) => new DelegateDeclaration() { ReturnType = new ArrayDecl() { ValueType = DTypeToTypeDeclVisitor.GenerateTypeDecl((t as AssocArrayType).ValueType) } }, RequireThis = true }); props.AddProp(new StaticPropertyInfo("get", null) { RequireThis = true, NodeGetter = (t, ctxt) => { var ad = t as AssocArrayType; var valueType = DTypeToTypeDeclVisitor.GenerateTypeDecl(ad.ValueType); return(new DMethod() { Name = "get", Description = "Looks up key; if it exists returns corresponding value else evaluates and returns defaultValue.", Type = valueType, Parameters = new List <INode> { new DVariable() { Name = "key", Type = DTypeToTypeDeclVisitor.GenerateTypeDecl(ad.KeyType) }, new DVariable() { Name = "defaultValue", Type = valueType, Attributes = new List <DAttribute> { new Modifier(DTokens.Lazy) } } } }); } }); props.AddProp(new StaticPropertyInfo("remove", null) { RequireThis = true, NodeGetter = (t, ctxt) => new DMethod { Name = "remove", Description = "remove(key) does nothing if the given key does not exist and returns false. If the given key does exist, it removes it from the AA and returns true.", Type = new DTokenDeclaration(DTokens.Bool), Parameters = new List <INode> { new DVariable { Name = "key", Type = DTypeToTypeDeclVisitor.GenerateTypeDecl((t as AssocArrayType).KeyType) } } } }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.TypeTuple] = props; props.AddProp(new StaticPropertyInfo("length", "Returns number of values in the type tuple.", "size_t") { RequireThis = true, ValueGetter = (vp, v) => { var tt = v as DTuple; if (tt == null && v is TypeValue) { tt = (v as TypeValue).RepresentedType as DTuple; } return(tt != null ? new PrimitiveValue(DTokens.Int, tt.Items == null ? 0m : (decimal)tt.Items.Length, null, 0m) : null); } }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.Delegate] = props; props.AddProp(new StaticPropertyInfo("ptr", "The .ptr property of a delegate will return the frame pointer value as a void*.", (ITypeDeclaration) new PointerDecl(new DTokenDeclaration(DTokens.Void))) { RequireThis = true }); props.AddProp(new StaticPropertyInfo("funcptr", "The .funcptr property of a delegate will return the function pointer value as a function type.") { RequireThis = true }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.ClassLike] = props; props.AddProp(new StaticPropertyInfo("classinfo", "Information about the dynamic type of the class", (ITypeDeclaration) new IdentifierDeclaration("TypeInfo_Class") { ExpressesVariableAccess = true, InnerDeclaration = new IdentifierDeclaration("object") }) { RequireThis = true }); props = new Dictionary <int, StaticPropertyInfo>(); Properties[PropOwnerType.Struct] = props; props.AddProp(new StaticPropertyInfo("sizeof", "Size in bytes of struct", DTokens.Uint)); props.AddProp(new StaticPropertyInfo("alignof", "Size boundary struct needs to be aligned on", DTokens.Uint)); props.AddProp(new StaticPropertyInfo("tupleof", "Gets type tuple of fields") { TypeGetter = (t, ctxt) => { var members = GetStructMembers(t as StructType, ctxt); var l = new List <IExpression>(); var vis = new DTypeToTypeDeclVisitor(); foreach (var member in members) { var mt = DResolver.StripMemberSymbols(member); if (mt == null) { l.Add(null); continue; } var td = mt.Accept(vis); if (td == null) { l.Add(null); continue; } l.Add(td as IExpression ?? new TypeDeclarationExpression(td)); } return(new TemplateInstanceExpression(new IdentifierDeclaration("Tuple")) { Arguments = l.ToArray() }); }, ResolvedBaseTypeGetter = (t, ctxt) => { var members = GetStructMembers(t as StructType, ctxt); var tupleItems = new List <ISemantic>(); foreach (var member in members) { var mt = DResolver.StripMemberSymbols(member); if (mt != null) { tupleItems.Add(mt); } } return(new DTuple(t.DeclarationOrExpressionBase, tupleItems)); } }); }
DVariable Argument(ref char c, out AbstractType parType) { bool scoped; if(scoped = (c == 'M')) c = (char)r.Read(); //TODO: Handle scoped var par = new DVariable{ Attributes = new List<DAttribute>() }; if(c == 'J' || c == 'K' ||c == 'L') { switch (c) { case 'J': par.Attributes.Add (new Modifier (DTokens.Out)); break; case 'K': par.Attributes.Add (new Modifier (DTokens.Ref)); break; case 'L': par.Attributes.Add (new Modifier (DTokens.Lazy)); break; } c = (char)r.Read(); } parType = Type(c); par.Type = DTypeToTypeDeclVisitor.GenerateTypeDecl(parType); return par; }
/// <summary> /// Checks results for implicit type convertability /// </summary> public static bool IsImplicitlyConvertible(ISemantic resultToCheck, AbstractType targetType, ResolutionContext ctxt = null) { var resToCheck = AbstractType.Get(resultToCheck); bool isVariable = resToCheck is MemberSymbol; // Initially remove aliases from results var _r = DResolver.StripMemberSymbols(resToCheck); if (_r == null) { return(IsEqual(resToCheck, targetType)); } resToCheck = _r; if (targetType is DSymbol) { var tpn = ((DSymbol)targetType).Definition as TemplateParameter.Node; if (tpn != null) { var par = tpn.Parent as DNode; if (par != null && par.TemplateParameters != null) { var dedParam = new DeducedTypeDictionary(par); return(new TemplateParameterDeduction(dedParam, ctxt).Handle(tpn.TemplateParameter, resToCheck)); } } } _r = DResolver.StripMemberSymbols(targetType); if (_r == null) { return(false); } targetType = _r; if (resToCheck is PrimitiveType && targetType is PrimitiveType) { var sr1 = (PrimitiveType)resToCheck; var sr2 = (PrimitiveType)targetType; //if (sr1.TypeToken == sr2.TypeToken /*&& sr1.Modifier == sr2.Modifier*/) // return true; return(IsPrimitiveTypeImplicitlyConvertible(sr1.TypeToken, sr2.TypeToken)); } else if (resToCheck is UserDefinedType && targetType is UserDefinedType) { return(IsImplicitlyConvertible((UserDefinedType)resToCheck, (UserDefinedType)targetType)); } else if (resToCheck is DelegateType && targetType is DelegateType) { return(IsEqual(resToCheck, targetType)); //TODO: Can non-equal delegates be converted into each other? } else if (resToCheck is ArrayType && targetType is ArrayType) { var ar1 = (ArrayType)resToCheck; var ar2 = (ArrayType)targetType; // Key as well as value types must be matching! var ar1_n = ar1.KeyType == null; var ar2_n = ar2.KeyType == null; if (ar1_n != ar2_n) { return(false); } if (ar1_n || IsImplicitlyConvertible(ar1.KeyType, ar2.KeyType, ctxt)) { return(IsImplicitlyConvertible(ar1.Base, ar2.Base, ctxt)); } } else if (resToCheck is DSymbol && targetType is DSymbol) { var r1 = resToCheck as DSymbol; var r2 = targetType as DSymbol; if (r1.Definition == r2.Definition) { //TODO: Compare template param deductions return(true); } } else if (resToCheck is DTuple && targetType is DTuple) { var tup1 = resToCheck as DTuple; var tup2 = resToCheck as DTuple; //TODO return(true); } /*else if (resultToCheck is ExpressionValueResult && targetType is ExpressionValue) * { * return ((ExpressionValueResult)resultToCheck).Value.Equals(((ExpressionValueResult)targetType).Value); * }*/ // http://dlang.org/type.html //TODO: Pointer to non-pointer / vice-versa checkability? -- Can it really be done implicitly? else if (!isVariable && resToCheck is ArrayType && targetType is PointerType && ((targetType = (targetType as PointerType).Base) is PrimitiveType) && DTokens.IsBasicType_Character((targetType as PrimitiveType).TypeToken)) { return((resultToCheck as ArrayType).IsString); } return(false); }
static AbstractType help_ReflectResolvedType(AbstractType t, ResolutionContext ctxt) { return(t); }
/// <summary> /// Checks results for implicit type convertability /// </summary> public static bool IsImplicitlyConvertible(ISemantic resultToCheck, AbstractType targetType, ResolverContextStack ctxt = null) { var resToCheck = AbstractType.Get(resultToCheck); // Initially remove aliases from results var _r = DResolver.StripMemberSymbols(resToCheck); if (_r == null) { return(IsEqual(resToCheck, targetType)); } resToCheck = _r; targetType = DResolver.StripAliasSymbol(targetType); if (targetType is DSymbol) { var tpn = ((DSymbol)targetType).Definition as TemplateParameterNode; if (tpn != null) { var par = tpn.Parent as DNode; if (par != null && par.TemplateParameters != null) { var dedParam = new DeducedTypeDictionary { ParameterOwner = par }; foreach (var tp in par.TemplateParameters) { dedParam[tp.Name] = null; } return(new TemplateParameterDeduction(dedParam, ctxt).Handle(tpn.TemplateParameter, resToCheck)); } } } _r = DResolver.StripMemberSymbols(targetType); if (_r == null) { return(false); } targetType = _r; if (resToCheck is PrimitiveType && targetType is PrimitiveType) { var sr1 = (PrimitiveType)resToCheck; var sr2 = (PrimitiveType)targetType; if (sr1.TypeToken == sr2.TypeToken && sr1.Modifier == sr2.Modifier) { return(true); } switch (sr2.TypeToken) { case DTokens.Int: return(sr1.TypeToken == DTokens.Uint); case DTokens.Uint: return(sr1.TypeToken == DTokens.Int); //TODO: Further types that can be converted into each other implicitly } } else if (resToCheck is UserDefinedType && targetType is UserDefinedType) { return(IsImplicitlyConvertible((UserDefinedType)resToCheck, (UserDefinedType)targetType)); } else if (resToCheck is DelegateType && targetType is DelegateType) { //TODO } else if (resToCheck is ArrayType && targetType is ArrayType) { var ar1 = (ArrayType)resToCheck; var ar2 = (ArrayType)targetType; // Key as well as value types must be matching! var ar1_n = ar1.KeyType == null; var ar2_n = ar2.KeyType == null; if (ar1_n != ar2_n) { return(false); } if (ar1_n || IsImplicitlyConvertible(ar1.KeyType, ar2.KeyType, ctxt)) { return(IsImplicitlyConvertible(ar1.Base, ar2.Base, ctxt)); } } else if (resToCheck is TypeTuple && targetType is TypeTuple) { return(true); } else if (resToCheck is ExpressionTuple && targetType is ExpressionTuple) { return(true); } /*else if (resultToCheck is ExpressionValueResult && targetType is ExpressionValue) * { * return ((ExpressionValueResult)resultToCheck).Value.Equals(((ExpressionValueResult)targetType).Value); * }*/ // http://dlang.org/type.html //TODO: Pointer to non-pointer / vice-versa checkability? -- Can it really be done implicitly? return(false); }
public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td) : base(Enum, BaseType, null, td) { }
public bool TryGetCachedResult(INode n, out AbstractType type, params IExpression[] templateArguments) { type = null; return(false); }
public ArrayType(AbstractType ValueType, int ArrayLength, ISyntaxRegion td) : this(ValueType, td) { FixedLength = ArrayLength; IsStaticArray = true; }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, Dictionary <string, TemplateParameterSymbol> deducedTypes) : base(member, memberType, deducedTypes, td) { }
public DelegateType(AbstractType ReturnType,DelegateDeclaration Declaration, IEnumerable<AbstractType> Parameters = null) : base(ReturnType, Declaration) { this.IsFunction = Declaration.IsFunction; if (Parameters is AbstractType[]) this.Parameters = (AbstractType[])Parameters; else if(Parameters!=null) this.Parameters = Parameters.ToArray(); }
public SubArrayCacheNode(string n, AbstractType t, ulong firstItemPointer, int len) : base(n, t, firstItemPointer) { firstItem = firstItemPointer; length = len; }
public DerivedDataType(AbstractType Base, ISyntaxRegion td) : base(td) { this.Base = Base; }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, ReadOnlyCollection <KeyValuePair <string, TemplateParameterSymbol> > deducedTypes = null) : base(member, memberType, deducedTypes, td) { }
public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td) : base(Enum, BaseType, null, td) { }
public ArrayType(AbstractType ValueType, ISyntaxRegion td) : base(ValueType, null, td) { FixedLength = -1; }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, IEnumerable<TemplateParameterSymbol> deducedTypes) : base(member, memberType, deducedTypes, td) { }
public ArrayType(AbstractType ValueType, int ArrayLength, ISyntaxRegion td) : this(ValueType, td) { FixedLength = ArrayLength; IsStaticArray = ArrayLength >= 0; }
public StaticProperty(DNode n, AbstractType bt, StaticProperties.ValueGetterHandler valueGetter) : base(n, bt, null) { this.n = n; this.ValueGetter = valueGetter; }
public AliasedType(DVariable AliasDefinition, AbstractType Type, ISyntaxRegion td, ReadOnlyCollection <KeyValuePair <string, TemplateParameterSymbol> > deducedTypes = null) : base(AliasDefinition, Type, td, deducedTypes) { }
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td, AbstractType baseType, InterfaceType[] baseInterfaces, IEnumerable<TemplateParameterSymbol> deducedTypes) : this(dc,td, baseType,baseInterfaces, deducedTypes != null ? new ReadOnlyCollection<TemplateParameterSymbol>(deducedTypes.ToArray()) : null) { }
public UserDefinedType(DNode Node, AbstractType baseType, ReadOnlyCollection <KeyValuePair <string, TemplateParameterSymbol> > deducedTypes, ISyntaxRegion td) : base(Node, baseType, deducedTypes, td) { }
void Function(out AbstractType returnType, out List<DAttribute> attributes, out Dictionary<INode,AbstractType> parameters, char callConvention = 'F') { attributes = new List<DAttribute>(); // Create artificial extern attribute var conv = "D"; switch(callConvention) { case 'U': conv = "C"; break; case 'W': conv = "Windows"; break; case 'V': conv = "Pascal"; break; case 'R': conv = "C++"; break; } attributes.Add(new Modifier(DTokens.Extern,conv)); var nextChar = '\0'; do { nextChar = (char)r.Read(); if(nextChar == 'N') { switch(r.Peek()) { case 'a': r.Read(); nextChar = (char)r.Read(); attributes.Add(new Modifier(DTokens.Pure)); continue; case 'b': r.Read(); nextChar = (char)r.Read(); attributes.Add(new Modifier(DTokens.Nothrow)); continue; case 'c': r.Read(); nextChar = (char)r.Read(); attributes.Add(new Modifier(DTokens.Ref)); continue; case 'd': r.Read(); nextChar = (char)r.Read(); attributes.Add(new BuiltInAtAttribute(BuiltInAtAttribute.BuiltInAttributes.Property)); continue; case 'e': r.Read(); nextChar = (char)r.Read(); attributes.Add(new BuiltInAtAttribute(BuiltInAtAttribute.BuiltInAttributes.Trusted)); continue; case 'f': r.Read(); nextChar = (char)r.Read(); attributes.Add(new BuiltInAtAttribute(BuiltInAtAttribute.BuiltInAttributes.Safe)); continue; } } } while(false); parameters = Arguments(ref nextChar); if(nextChar == 'X') // variadic T t...) style { var lastParam = parameters.Keys.Last(); lastParam.Type = new VarArgDecl(lastParam.Type); } else if(nextChar == 'Y') // variadic T t,...) style parameters.Add(new DVariable{ Type = new VarArgDecl() }, null); else if(nextChar != 'Z') throw new ArgumentException("Expected 'X','Y' or 'Z' at the end of a function type."); returnType = Type(); }
public DSymbol(DNode Node, AbstractType BaseType, ReadOnlyCollection <KeyValuePair <string, TemplateParameterSymbol> > deducedTypes, ISyntaxRegion td) : base(BaseType, td) { this.DeducedTypes = deducedTypes; this.Definition = Node; }
protected DerivedDataType(AbstractType Base, ISyntaxRegion td) : base(td) { this.Base = Base; }
static ITypeDeclaration help_ReflectType(AbstractType t, ResolutionContext ctxt) { return(DTypeToTypeDeclVisitor.GenerateTypeDecl(t)); }
public ArrayAccessSymbol(PostfixExpression_Index indexExpr, AbstractType arrayValueType) : base(arrayValueType, indexExpr) { }
public PointerType(AbstractType Base, ISyntaxRegion td) : base(Base, td) { }