public static string GetScriptName(AstType type, bool separator)
{
string result = null;
SimpleType simpleType = type as SimpleType;
if (simpleType != null)
{
result = Helpers.GetScriptName(simpleType.Identifier, simpleType.TypeArguments.Count, separator);
}
else
{
PrimitiveType primType = type as PrimitiveType;
if (primType != null)
{
result = Helpers.GetScriptName(primType.KnownTypeCode.ToString(), 0, separator);
}
else
{
result = Helpers.GetScriptName(type.ToString(), 0, separator);
}
}
var composedType = type as ComposedType;
if (composedType != null)
{
result = Helpers.GetScriptName(composedType.BaseType, separator) + "." + result;
}
return(result);
}
string TypeToString(IType type, ITypeDefinition currentTypeDef = null)
{
var builder = CreateBuilder(currentTypeDef);
AstType node = builder.ConvertType(type);
return(node.ToString());
}
void ReplaceType(AstType type)
{
int length = type.EndLocation.Column - type.StartLocation.Column;
int offset = type.StartLocation.Column - 1;
ReplaceType(type.ToString(), 0, offset, length);
}
public static string ToJsName(AstType astType, IEmitter emitter)
{
var simpleType = astType as SimpleType;
if (simpleType != null && simpleType.Identifier == "dynamic")
{
return(JS.Types.System.Object.NAME);
}
var resolveResult = emitter.Resolver.ResolveNode(astType, emitter);
var symbol = resolveResult.Type as ISymbol;
var name = BridgeTypes.ToJsName(
resolveResult.Type,
emitter,
astType.Parent is TypeOfExpression && symbol != null && symbol.SymbolKind == SymbolKind.TypeDefinition);
if (name != CS.NS.BRIDGE && !name.StartsWith(CS.Bridge.DOTNAME) && astType.ToString().StartsWith(CS.NS.GLOBAL))
{
return(JS.Types.Bridge.Global.DOTNAME + name);
}
return(name);
}
public virtual TypeDefinition GetTypeDefinition(AstType reference, bool safe = false)
{
string name = Helpers.GetScriptName(reference, true);
name = this.ResolveType(name, reference);
if (name.IsEmpty() || !this.TypeDefinitions.ContainsKey(name))
{
var resolveResult = this.Resolver.ResolveNode(reference, this) as TypeResolveResult;
if (resolveResult != null)
{
var type = resolveResult.Type as DefaultTypeParameter;
if (type != null && type.EffectiveBaseClass != null)
{
name = Helpers.GetScriptFullName(type.EffectiveBaseClass);
name = this.ResolveType(name, reference);
if (this.TypeDefinitions.ContainsKey(name))
{
return(this.TypeDefinitions[name]);
}
}
}
if (safe)
{
return(null);
}
throw new Exception("Type cannot be resolved: " + reference.ToString());
}
if (this.TypeDefinitions.ContainsKey(name))
{
return(this.TypeDefinitions[name]);
}
if (safe)
{
return(null);
}
throw new Exception("Type cannot be resolved: " + reference.ToString());
}
string TypeToString(ITypeReference type, ITypeDefinition currentTypeDef = null)
{
var builder = CreateBuilder(currentTypeDef);
IType resolvedType = type.Resolve(ctx);
AstType node = builder.ConvertType(resolvedType);
return(node.ToString());
}
public static object GetDefaultFieldValue(AstType type, IMemberResolver resolver)
{
if (type is PrimitiveType)
{
var primitiveType = (PrimitiveType)type;
switch (primitiveType.KnownTypeCode)
{
case KnownTypeCode.Decimal:
return(0m);
case KnownTypeCode.Int16:
case KnownTypeCode.Int32:
case KnownTypeCode.Int64:
case KnownTypeCode.UInt16:
case KnownTypeCode.UInt32:
case KnownTypeCode.UInt64:
case KnownTypeCode.Byte:
case KnownTypeCode.Double:
case KnownTypeCode.SByte:
case KnownTypeCode.Single:
return(0);
case KnownTypeCode.Boolean:
return(false);
case KnownTypeCode.Char:
return((int)'0');
}
}
var resolveResult = resolver.ResolveNode(type, null);
if (resolveResult.Type.Kind == TypeKind.TypeParameter)
{
if (resolveResult.Type.IsReferenceType == null || resolveResult.Type.IsReferenceType == false)
{
return(new RawString(type.ToString() + '.' + TransformCtx.DefaultInvoke));
}
}
if (!resolveResult.IsError && NullableType.IsNullable(resolveResult.Type))
{
return(null);
}
if (!resolveResult.IsError && resolveResult.Type.Kind == TypeKind.Enum)
{
return(0);
}
if (!resolveResult.IsError && resolveResult.Type.Kind == TypeKind.Struct)
{
return(type);
}
return(null);
}
public static object GetDefaultFieldValue(IType type, AstType astType, bool wrapType = true)
{
if (type.Kind == TypeKind.TypeParameter && astType != null)
{
return(new RawValue(JS.Funcs.BRIDGE_GETDEFAULTVALUE + "(" + astType.ToString() + ")"));
}
if (type.IsKnownType(KnownTypeCode.Decimal))
{
return(0m);
}
if (type.IsKnownType(KnownTypeCode.Int64))
{
return(0L);
}
if (type.IsKnownType(KnownTypeCode.UInt64))
{
return(0UL);
}
if (type.IsKnownType(KnownTypeCode.Int16) ||
type.IsKnownType(KnownTypeCode.Int32) ||
type.IsKnownType(KnownTypeCode.UInt16) ||
type.IsKnownType(KnownTypeCode.UInt32) ||
type.IsKnownType(KnownTypeCode.Byte) ||
type.IsKnownType(KnownTypeCode.Double) ||
type.IsKnownType(KnownTypeCode.SByte) ||
type.IsKnownType(KnownTypeCode.Single) ||
type.IsKnownType(KnownTypeCode.Enum))
{
return(0);
}
if (NullableType.IsNullable(type))
{
return(null);
}
if (type.IsKnownType(KnownTypeCode.Boolean))
{
return(false);
}
if (type.IsKnownType(KnownTypeCode.Enum) || type.Kind == TypeKind.Enum)
{
return(0);
}
if (type.Kind == TypeKind.Struct && wrapType)
{
return(type);
}
return(null);
}
/// <summary>
/// Determines whether the types are equal.
/// </summary>
/// <param name="expectedType">The expected type.</param>
/// <param name="typeReference">The type reference.</param>
/// <returns><c>true</c> if parameters are equal, otherwise <c>false</c>.</returns>
private static bool AreTypesEqual(string expectedType, AstType typeReference)
{
SimpleType simpleType = typeReference as SimpleType; // Generic types
if (simpleType != null)
{
if (simpleType.TypeArguments.Count == 1)
{
typeReference = simpleType.TypeArguments.First();
}
else if (simpleType.TypeArguments.Count >= 2)
{
// This can't be handled correctly
return(true);
}
}
ComposedType composedType = typeReference as ComposedType; // Arrays
if (composedType != null)
{
if (!expectedType.EndsWith("[]", StringComparison.Ordinal))
{
return(false);
}
else
{
expectedType = expectedType.Replace("[]", string.Empty);
typeReference = composedType.BaseType;
}
}
if (expectedType.StartsWith("ref ", StringComparison.Ordinal))
{
expectedType = expectedType.Replace("ref ", string.Empty);
}
string typeReplacement;
if (TypeReplacements.TryGetValue(expectedType, out typeReplacement))
{
expectedType = typeReplacement;
}
// Validate
string typeName = typeReference.ToString();
if (expectedType.Equals(typeName, StringComparison.OrdinalIgnoreCase) ||
("System." + expectedType).Equals(typeName, StringComparison.OrdinalIgnoreCase) ||
expectedType.Substring(expectedType.LastIndexOf('.') + 1).Equals(typeName, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
CodeAction ReplaceWithFullTypeNameAction(RefactoringContext context, AstNode node, ITypeDefinition typeDefinition)
{
AstType astType = context.CreateShortType(typeDefinition);
string textWithoutGenerics = astType.ToString();
foreach (var typeArg in node.GetChildrenByRole(Roles.TypeArgument))
{
astType.AddChild(typeArg.Clone(), Roles.TypeArgument);
}
return(new CodeAction(textWithoutGenerics, s => s.Replace(node, astType), node));
}
private static bool CheckName(AstType type, params string[] names)
{
if (type == null || names == null)
{
return(false);
}
var typeName = type.ToString();
return(names.Any(name => typeName == name));
}
Expression FromJSValue(AstType type, Expression expression)
{
var primitiveType = type as PrimitiveType;
TypeData enumType;
if (Types.TryGetType(type.ToString(), out enumType) && enumType.IsEnum)
{
primitiveType = enumType.DeclaredType.BaseType as PrimitiveType;
}
else
{
enumType = null;
}
string toMethod;
switch (primitiveType?.Keyword)
{
case "string":
toMethod = "ToNullableString";
break;
case "int":
toMethod = "ToInt32";
break;
case "uint":
case "ushort":
toMethod = "ToUInt32";
break;
case "bool":
toMethod = "ToBool";
break;
case "double":
toMethod = "ToDouble";
break;
default:
if (primitiveType != null)
{
throw new Exception($"unsupported primitive type: {primitiveType}");
}
return(new IdentifierExpression("Wrap")
{
TypeArguments = { type.Clone() }
}.Invoke(expression));
}
expression = new InvocationExpression(new MemberReferenceExpression(expression, toMethod));
return(enumType != null?expression.CastTo(type.Clone()) : expression);
}
string TypeToString(IType type, ITypeDefinition currentTypeDef = null, Action <TypeSystemAstBuilder> builderAction = null)
{
var builder = CreateBuilder(currentTypeDef);
if (builderAction != null)
{
builderAction(builder);
}
AstType node = builder.ConvertType(type);
return(node.ToString());
}
public string ConvertType(IType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
return(astType.ToString());
}
public override void VisitForeachStatement(ForeachStatement foreachStatement)
{
base.VisitForeachStatement(foreachStatement);
var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult;
if (rr == null)
{
return;
}
if (rr.ElementType.Kind == TypeKind.Unknown || rr.ElementVariable.Type.Kind == TypeKind.Unknown)
{
return;
}
if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object)
{
return;
}
if (conversions == null)
{
conversions = CSharpConversions.Get(ctx.Compilation);
}
Conversion c = conversions.ImplicitConversion(rr.ElementType, rr.ElementVariable.Type);
if (c.IsValid)
{
return;
}
var csResolver = ctx.GetResolverStateBefore(foreachStatement);
var builder = new TypeSystemAstBuilder(csResolver);
AstType elementType = builder.ConvertType(rr.ElementType);
AstType variableType = foreachStatement.VariableType;
string issueText = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'");
string fixText = ctx.TranslateString("Use type '{0}'");
AddIssue(new CodeIssue(variableType, string.Format(issueText, elementType.ToString(), variableType.ToString()),
new CodeAction(
string.Format(fixText, elementType.ToString()),
script => script.Replace(variableType, elementType),
foreachStatement)));
}
public string ConvertType(IType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
AstType astType = astBuilder.ConvertType(type);
return(astType.ToString());
}
Expression ToJSValue(AstType type, Expression expression)
{
TypeData typeData;
if (Types.TryGetType(type.ToString(), out typeData))
{
if (typeData.IsEnum)
{
expression = expression.CastTo(typeData.DeclaredType.BaseType);
}
else if (typeData.DeclaredType.BaseType != null)
{
expression = new MemberReferenceExpression(expression, BackingFieldName);
}
}
return(new InvocationExpression(
MemberReference("JSValue", "From"),
expression,
MemberReference(BackingFieldName, "Context")
));
}
public static object GetDefaultFieldValue(IType type, AstType astType, bool wrapType = true)
{
if (type.Kind == TypeKind.TypeParameter && astType != null)
{
var parameter = type as ITypeParameter;
if (parameter != null && (
parameter.Owner.Attributes.Any(a => a.AttributeType.FullName == "Bridge.IgnoreGenericAttribute") ||
parameter.Owner.DeclaringTypeDefinition != null && parameter.Owner.DeclaringTypeDefinition.Attributes.Any(a => a.AttributeType.FullName == "Bridge.IgnoreGenericAttribute")))
{
return(null);
}
return(new RawValue(JS.Funcs.BRIDGE_GETDEFAULTVALUE + "(" + astType.ToString() + ")"));
}
if (type.IsKnownType(KnownTypeCode.Decimal))
{
return(0m);
}
if (type.IsKnownType(KnownTypeCode.Int64))
{
return(0L);
}
if (type.IsKnownType(KnownTypeCode.UInt64))
{
return(0UL);
}
if (type.IsKnownType(KnownTypeCode.Char) ||
type.IsKnownType(KnownTypeCode.Int16) ||
type.IsKnownType(KnownTypeCode.Int32) ||
type.IsKnownType(KnownTypeCode.UInt16) ||
type.IsKnownType(KnownTypeCode.UInt32) ||
type.IsKnownType(KnownTypeCode.Byte) ||
type.IsKnownType(KnownTypeCode.Double) ||
type.IsKnownType(KnownTypeCode.SByte) ||
type.IsKnownType(KnownTypeCode.Single) ||
type.IsKnownType(KnownTypeCode.Enum))
{
return(0);
}
if (NullableType.IsNullable(type))
{
return(null);
}
if (type.IsKnownType(KnownTypeCode.Boolean))
{
return(false);
}
if (type.IsKnownType(KnownTypeCode.Enum) || type.Kind == TypeKind.Enum)
{
return(0);
}
if (type.Kind == TypeKind.Struct && wrapType)
{
return(type);
}
return(null);
}
string GenerateNamespaceString(AstType astType)
{
return astType.ToString();
}
/// <summary>
/// Check if the type should be skipped to generate 'Contract.Ensures' and 'Contract.Requires' statemets.
/// </summary>
/// <param name="type">the type</param>
/// <returns>true: skip type</returns>
public static bool IsSkipType(AstType type)
{
string typeName = type.HasChildren ? type.FirstChild.ToString() : type.ToString();
if (SkipTypes == null)
{
return false;
}
return SkipTypes.Any(s => s.ToUpper() == typeName.ToUpper());
}
IEnumerable<ICompletionData> CreateTypeCompletionData(IType hintType, AstType hintTypeAst)
{
var wrapper = new CompletionDataWrapper(this);
var state = GetState();
Func<IType, IType> pred = null;
if (hintType != null) {
if (hintType.Kind != TypeKind.Unknown) {
var lookup = new MemberLookup(ctx.CurrentTypeDefinition, Compilation.MainAssembly);
pred = t => {
// check if type is in inheritance tree.
if (hintType.GetDefinition() != null && !t.GetDefinition().IsDerivedFrom(hintType.GetDefinition())) {
return null;
}
if (t.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array) {
return null;
}
// check for valid constructors
if (t.GetConstructors().Count() > 0) {
bool isProtectedAllowed = currentType != null ? currentType.Resolve(ctx).GetDefinition().IsDerivedFrom(t.GetDefinition()) : false;
if (!t.GetConstructors().Any(m => lookup.IsAccessible(m, isProtectedAllowed)))
return null;
}
var typeInference = new TypeInference(Compilation);
typeInference.Algorithm = TypeInferenceAlgorithm.ImprovedReturnAllResults;
var inferedType = typeInference.FindTypeInBounds(new [] { t }, new [] { hintType });
wrapper.AddType(inferedType, amb.ConvertType(inferedType));
return null;
};
if (!(hintType.Kind == TypeKind.Interface && hintType.Kind != TypeKind.Array)) {
DefaultCompletionString = GetShortType(hintType, GetState());
wrapper.AddType(hintType, DefaultCompletionString);
}
if (hintType is ParameterizedType && hintType.TypeParameterCount == 1 && hintType.FullName == "System.Collections.Generic.IEnumerable") {
var arg = ((ParameterizedType)hintType).TypeArguments.FirstOrDefault();
var array = new ArrayTypeReference(arg.ToTypeReference(), 1).Resolve(ctx);
wrapper.AddType(array, amb.ConvertType(array));
}
} else {
DefaultCompletionString = hintTypeAst.ToString();
wrapper.AddType(hintType, DefaultCompletionString);
}
}
AddTypesAndNamespaces(wrapper, state, null, pred, m => false);
if (hintType == null || hintType == SpecialType.UnknownType)
AddKeywords(wrapper, primitiveTypesKeywords.Where(k => k != "void"));
CloseOnSquareBrackets = true;
AutoCompleteEmptyMatch = true;
return wrapper.Result;
}
/// <summary>
/// Determines whether the types are equal.
/// </summary>
/// <param name="expectedType">The expected type.</param>
/// <param name="typeReference">The type reference.</param>
/// <returns><c>true</c> if parameters are equal, otherwise <c>false</c>.</returns>
private static bool AreTypesEqual(string expectedType, AstType typeReference)
{
SimpleType simpleType = typeReference as SimpleType; // Generic types
if (simpleType != null)
{
if (simpleType.TypeArguments.Count == 1)
{
typeReference = simpleType.TypeArguments.First();
}
else if (simpleType.TypeArguments.Count >= 2)
{
// This can't be handled correctly
return true;
}
}
ComposedType composedType = typeReference as ComposedType; // Arrays
if (composedType != null)
{
if (!expectedType.EndsWith("[]", StringComparison.Ordinal))
{
return false;
}
else
{
expectedType = expectedType.Replace("[]", string.Empty);
typeReference = composedType.BaseType;
}
}
if (expectedType.StartsWith("ref ", StringComparison.Ordinal))
{
expectedType = expectedType.Replace("ref ", string.Empty);
}
string typeReplacement;
if (TypeReplacements.TryGetValue(expectedType, out typeReplacement))
{
expectedType = typeReplacement;
}
// Validate
string typeName = typeReference.ToString();
if (expectedType.Equals(typeName, StringComparison.OrdinalIgnoreCase)
|| ("System." + expectedType).Equals(typeName, StringComparison.OrdinalIgnoreCase)
|| expectedType.Substring(expectedType.LastIndexOf('.') + 1).Equals(typeName, StringComparison.OrdinalIgnoreCase))
{
return true;
}
return false;
}
void ReplaceType(AstType type)
{
int length = type.EndLocation.Column - type.StartLocation.Column;
int offset = type.StartLocation.Column - 1;
ReplaceType (type.ToString (), offset, length);
}
IEnumerable<ICompletionData> CreateTypeCompletionData(IType hintType, AstType hintTypeAst)
{
var wrapper = new CompletionDataWrapper (this);
var state = GetState ();
Predicate<IType> pred = null;
if (hintType != null) {
if (hintType.Kind != TypeKind.Unknown) {
var lookup = new MemberLookup (ctx.CurrentTypeDefinition, Compilation.MainAssembly);
pred = t => {
// check if type is in inheritance tree.
if (hintType.GetDefinition () != null && !t.GetDefinition ().IsDerivedFrom (hintType.GetDefinition ()))
return false;
// check for valid constructors
if (t.GetConstructors ().Count () == 0)
return true;
bool isProtectedAllowed = currentType != null ? currentType.Resolve (ctx).GetDefinition ().IsDerivedFrom (t.GetDefinition ()) : false;
return t.GetConstructors ().Any (m => lookup.IsAccessible (m, isProtectedAllowed));
};
DefaultCompletionString = GetShortType (hintType, GetState ());
wrapper.AddType (hintType, DefaultCompletionString);
} else {
DefaultCompletionString = hintTypeAst.ToString ();
wrapper.AddType (hintType, DefaultCompletionString);
}
}
AddTypesAndNamespaces (wrapper, state, null, pred, m => false);
AddKeywords (wrapper, primitiveTypesKeywords.Where (k => k != "void"));
CloseOnSquareBrackets = true;
AutoCompleteEmptyMatch = true;
return wrapper.Result;
}
public static string TranslateTypeReference(AstType astType, IEmitter emitter)
{
var composedType = astType as ComposedType;
if (composedType != null && composedType.ArraySpecifiers != null && composedType.ArraySpecifiers.Count > 0)
{
return("Array");
}
var simpleType = astType as SimpleType;
if (simpleType != null && simpleType.Identifier == "dynamic")
{
return("Object");
}
string type = emitter.ResolveType(Helpers.GetScriptName(astType, true), astType);
if (String.IsNullOrEmpty(type))
{
throw (Exception)emitter.CreateException(astType, "Cannot resolve type " + astType.ToString());
}
var name = type;
if (emitter.TypeDefinitions.ContainsKey(name))
{
name = emitter.ShortenTypeName(type);
}
if (simpleType != null && simpleType.TypeArguments.Count > 0 && !Helpers.IsIgnoreGeneric(simpleType, emitter))
{
StringBuilder sb = new StringBuilder(name);
bool needComma = false;
sb.Append("(");
foreach (var typeArg in simpleType.TypeArguments)
{
if (needComma)
{
sb.Append(",");
}
needComma = true;
sb.Append(Helpers.TranslateTypeReference(typeArg, emitter));
}
sb.Append(")");
name = sb.ToString();
}
return(name);
}