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 StaticProperty(DNode n, AbstractType bt, StaticProperties.ValueGetterHandler valueGetter) : base(n, bt, null)
{
this.n = n;
this.ValueGetter = valueGetter;
}
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 DerivedDataType(AbstractType Base, ISyntaxRegion td) : base(td)
{
this.Base = Base;
}
public UserDefinedType(DNode Node, AbstractType baseType, ReadOnlyCollection<TemplateParameterSymbol> deducedTypes, ISyntaxRegion td) : base(Node, baseType, deducedTypes, td) { }
public PointerType(AbstractType Base, ISyntaxRegion td) : base(Base, td)
{
}
public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td) : base(Enum, BaseType, null, td) { }
public ArrayType(AbstractType ValueType, ISyntaxRegion td)
: base(ValueType, new PrimitiveType(DTokens.Int, 0), td)
{
FixedLength = -1;
}
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 ArrayType(AbstractType ValueType, int ArrayLength, ISyntaxRegion td)
: this(ValueType, td)
{
FixedLength = ArrayLength;
IsStaticArray = true;
}
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 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);
}
