public DNode GenerateRepresentativeNode(AbstractType t) { if (NodeGetter != null) return NodeGetter(t); return new DVariable() { Attributes = !RequireThis ? StaticAttributeList : null, Name = Name, Description = Description, Type = GetPropertyType(t) }; }
public DNode GenerateRepresentativeNode(AbstractType t) { if (NodeGetter != null) { return(NodeGetter(t)); } return(new DVariable() { Attributes = !RequireThis ? StaticAttributeList : null, Name = Name, Description = Description, Type = GetPropertyType(t) }); }
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 static IEnumerable <DNode> ListProperties(AbstractType t, bool staticOnly = false) { if (t is PointerType) { t = (t as PointerType).Base; } t = DResolver.StripMemberSymbols(t); if (t is PointerType) { t = (t as PointerType).Base; } if (t == null) { yield break; } var props = Properties[PropOwnerType.Generic]; foreach (var kv in props) { if (!staticOnly || !kv.Value.RequireThis) { yield return(kv.Value.GenerateRepresentativeNode(t)); } } if (Properties.TryGetValue(GetOwnerType(t), out props)) { foreach (var kv in props) { if (!staticOnly || !kv.Value.RequireThis) { yield return(kv.Value.GenerateRepresentativeNode(t)); } } } }
static PropOwnerType GetOwnerType(AbstractType t) { if (t is ArrayType) { return(PropOwnerType.Array); } else if (t is AssocArrayType) { return(PropOwnerType.AssocArray); } else if (t is DelegateType) { return(PropOwnerType.Delegate); } else if (t is PrimitiveType) { var tk = (t as PrimitiveType).TypeToken; if (DTokens.BasicTypes_Integral[tk]) { return(PropOwnerType.Integral); } if (DTokens.BasicTypes_FloatingPoint[tk]) { return(PropOwnerType.FloatingPoint); } } else if (t is ClassType || t is InterfaceType || t is TemplateType || t is StructType) { return(PropOwnerType.ClassLike); } else if (t is DTuple) { return(PropOwnerType.TypeTuple); } return(PropOwnerType.None); }
public ArrayAccessSymbol(PostfixExpression_Index indexExpr, AbstractType arrayValueType) : base(arrayValueType, indexExpr) { }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, IEnumerable <TemplateParameterSymbol> deducedTypes) : base(member, memberType, deducedTypes, td) { }
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 <TemplateParameterSymbol> deducedTypes = null) : base(AliasDefinition, Type, td, deducedTypes) { }
static ITypeDeclaration help_ReflectType(AbstractType t) { return(t.TypeDeclarationOf); }
public ITypeDeclaration GetPropertyType(AbstractType t) { return(OverrideType ?? (TypeGetter != null && t != null ? TypeGetter(t) : null)); }
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 ITypeDeclaration GetPropertyType(AbstractType t) { return OverrideType ?? (TypeGetter != null && t != null ? TypeGetter(t) : null); }
public static StaticProperty TryEvalPropertyType(ResolutionContext ctxt, AbstractType t, int propName, bool staticOnly = false) { if (t is PointerType) t = (t as PointerType).Base; t = DResolver.StripMemberSymbols(t); if (t is PointerType) t = (t as PointerType).Base; 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 IEnumerable<DNode> ListProperties(AbstractType t, bool staticOnly = false) { if (t is PointerType) t = (t as PointerType).Base; t = DResolver.StripMemberSymbols(t); if (t is PointerType) t = (t as PointerType).Base; if (t == null) yield break; var props = Properties[PropOwnerType.Generic]; foreach (var kv in props) if(!staticOnly || !kv.Value.RequireThis) yield return kv.Value.GenerateRepresentativeNode(t); if (Properties.TryGetValue(GetOwnerType(t), out props)) foreach (var kv in props) if (!staticOnly || !kv.Value.RequireThis) yield return kv.Value.GenerateRepresentativeNode(t); }
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); }
public PointerType(AbstractType Base, ISyntaxRegion td) : base(Base, td) { }
public AliasedType(DVariable AliasDefinition, AbstractType Type, ISyntaxRegion td, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes=null) : base(AliasDefinition,Type, td, deducedTypes) {}
public ArrayType(AbstractType ValueType, int ArrayLength, ISyntaxRegion td) : this(ValueType, td) { FixedLength = ArrayLength; IsStaticArray = true; }
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 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); } } }
public TemplateIntermediateType(DClassLike dc, ISyntaxRegion td, AbstractType baseType = null, InterfaceType[] baseInterfaces = null, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null) : base(dc, baseType, deducedTypes, td) { this.BaseInterfaces = baseInterfaces; }
public DelegateValue(AbstractType Definition, AbstractType ReturnType, bool IsFunction = false) : base(ReturnType) { this.IsFunction = IsFunction; this.Definition = Definition; }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, IEnumerable<TemplateParameterSymbol> deducedTypes) : base(member, memberType, deducedTypes, td) { }
public InstanceValue(DClassLike Class, AbstractType ClassType) : base(Class, ClassType) { }
public UserDefinedType(DNode Node, AbstractType baseType, ReadOnlyCollection <TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(Node, baseType, deducedTypes, td) { }
public TypeValue(AbstractType r) : base(r) { }
public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td) : base(Enum, BaseType, null, td) { }
public ReferenceValue(INode Node, AbstractType type) : base(type) { }
public MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, ReadOnlyCollection <TemplateParameterSymbol> deducedTypes = null) : base(member, memberType, deducedTypes, td) { }
public InternalOverloadValue(AbstractType[] overloads) : base(null) { this.Overloads = overloads; }
public TemplateParameterSymbol(TemplateParameter tpn, ISemantic typeOrValue, ISyntaxRegion paramIdentifier = null) : base(tpn != null ? tpn.Representation : null, AbstractType.Get(typeOrValue), paramIdentifier) { this.Parameter = tpn; this.ParameterValue = typeOrValue as ISymbolValue; }
public bool TryGetCachedResult(INode n, out AbstractType type, params IExpression[] templateArguments) { type = null; return(false); }
public DerivedDataType(AbstractType Base, ISyntaxRegion td) : base(td) { this.Base = Base; }
/// <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; targetType = DResolver.StripAliasSymbol(targetType); 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; 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) 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 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.CharTypes[(targetType as PrimitiveType).TypeToken]) return (resultToCheck as ArrayType).IsString; return false; }
public ArrayType(AbstractType ValueType, ISyntaxRegion td) : base(ValueType, new PrimitiveType(DTokens.Int, 0), td) { FixedLength = -1; }
void BuildCompletionData( AbstractType rr, IBlockNode currentlyScopedBlock, bool isVariableInstance = false, AbstractType resultParent = null) { if (rr == null) return; if(rr.DeclarationOrExpressionBase is ITypeDeclaration) isVariableInstance |= (rr.DeclarationOrExpressionBase as ITypeDeclaration).ExpressesVariableAccess; if (rr is ArrayAccessSymbol) { isVariableInstance = true; rr = (rr as ArrayAccessSymbol).Base; } if (rr is MemberSymbol) BuildCompletionData((MemberSymbol)rr, currentlyScopedBlock, isVariableInstance); // A module path has been typed else if (!isVariableInstance && rr is ModuleSymbol) BuildCompletionData((ModuleSymbol)rr); else if (rr is PackageSymbol) BuildCompletionData((PackageSymbol)rr); #region A type was referenced directly else if (rr is EnumType) { var en = (EnumType)rr; foreach (var e in en.Definition) CompletionDataGenerator.Add(e); } else if (rr is TemplateIntermediateType) { var tr = (TemplateIntermediateType)rr; if (tr.DeclarationOrExpressionBase is TokenExpression) { int token = ((TokenExpression)tr.DeclarationOrExpressionBase).Token; isVariableInstance = token == DTokens.This || token == DTokens.Super; } // Cases: // myVar. (located in basetype definition) <-- Show everything // this. <-- Show everything // myVar. (not located in basetype definition) <-- Show public and public static members // super. <-- Show all base type members // myClass. (not located in myClass) <-- Show all static members // myClass. (located in myClass) <-- Show all static members BuildCompletionData(tr, isVariableInstance); } #endregion else if (rr is PointerType) { var pt = (PointerType)rr; if (!(pt.Base is PrimitiveType && pt.Base.DeclarationOrExpressionBase is PointerDecl)) BuildCompletionData(pt.Base, currentlyScopedBlock, true, pt); } else StaticProperties.ListProperties(CompletionDataGenerator, MemberFilter, rr, isVariableInstance); }
public AssocArrayType(AbstractType ValueType, AbstractType KeyType, ISyntaxRegion td) : base(ValueType, td) { this.KeyType = KeyType; }
void HandleResult(ISyntaxRegion sr, AbstractType t) { if (t is UserDefinedType) result.TypeMatches.Add(sr); }
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(); }
public UserDefinedType(DNode Node, AbstractType baseType, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(Node, baseType, deducedTypes, td) { }
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 MemberSymbol(DNode member, AbstractType memberType, ISyntaxRegion td, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes = null) : base(member, memberType, deducedTypes, td) { }
public ArrayAccessSymbol(PostfixExpression_Index indexExpr, AbstractType arrayValueType): base(arrayValueType,indexExpr) { }
/// <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; targetType = DResolver.StripAliasSymbol(targetType); 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); } 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) { 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 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.CharTypes[(targetType as PrimitiveType).TypeToken]) { return((resultToCheck as ArrayType).IsString); } return(false); }