From 0d23da9ea6f7319a605d239cdb188a276b84393e Mon Sep 17 00:00:00 2001 From: Hackerpilot Date: Tue, 13 Nov 2012 15:07:08 -0800 Subject: [PATCH] Slightly better autocomplete for arrays. It still doesn't work properly --- autocomplete.d | 39 ++++++++++++----------- langutils.d | 9 ++++++ types.d | 84 ++++++++++++++++++++++++++++++++++++++------------ 3 files changed, 92 insertions(+), 40 deletions(-) diff --git a/autocomplete.d b/autocomplete.d index 03fe180..510a81d 100644 --- a/autocomplete.d +++ b/autocomplete.d @@ -99,6 +99,8 @@ body case TokenType.Delete: case TokenType.LBrace: case TokenType.LParen: + case TokenType.Equals: + case TokenType.Plus: case TokenType.Import: case TokenType.LBracket: case TokenType.Comma: @@ -156,6 +158,7 @@ struct AutoComplete string getTypeOfExpression(const(Token)[] expression, const Token[] tokens, size_t cursor) { + stderr.writeln("getting type of ", expression); if (expression.length == 0) return "void"; auto type = typeOfVariable(expression[0], cursor); @@ -182,25 +185,9 @@ struct AutoComplete if (symbol.value in typeProperties) return symbol.value; - switch (symbol.type) - { - case TokenType.FloatLiteral: - return "float"; - case TokenType.DoubleLiteral: - return "double"; - case TokenType.RealLiteral: - return "real"; - case TokenType.IntLiteral: - return "int"; - case TokenType.UnsignedIntLiteral: - return "uint"; - case TokenType.LongLiteral: - return "long"; - case TokenType.UnsignedLongLiteral: - return "ulong"; - default: - break; - } + string tokenType = getTypeFromToken(symbol); + if (tokenType !is null) + return tokenType; if (context.getMembersOfType(symbol.value)) return symbol.value; @@ -220,18 +207,28 @@ struct AutoComplete { // Found the symbol, now determine if it was declared here. auto p = preceedingTokens[index - 1]; + + if ((p == TokenType.Auto || p == TokenType.Immutable || p == TokenType.Const) && preceedingTokens[index + 1] == TokenType.Assign) { - return null; + // Try to determine the type of a variable declared as "auto" + return getTypeOfExpression( + tokens[index + 2 .. findEndOfExpression(tokens, index + 2)], + tokens, cursor); } else if (p == TokenType.Identifier || (p.type > TokenType.TYPES_BEGIN && p.type < TokenType.TYPES_END)) { + // Handle simple cases like "int a;" or "Someclass instance;" return p.value; } + else if (p == TokenType.RBracket || p == TokenType.RParen) + { + return combineTokens(tokens[findBeginningOfExpression(tokens, index) .. index]); + } } if (index == 0) break; @@ -307,6 +304,8 @@ struct AutoComplete auto expressionType = getTypeOfExpression( splitCallChain(tokens[startIndex .. index]), tokens, cursor); + stderr.writeln("expression type is ", expressionType); + // Complete pointers and references the same way if (expressionType[$ - 1] == '*') expressionType = expressionType[0 .. $ - 1]; diff --git a/langutils.d b/langutils.d index 42018b4..0e4caf2 100644 --- a/langutils.d +++ b/langutils.d @@ -4,6 +4,8 @@ // http://www.boost.org/LICENSE_1_0.txt) module langutils; +import std.array; + /** * Returns: true if input is a access attribute @@ -43,6 +45,13 @@ pure nothrow TokenType lookupTokenType(const string input) return TokenType.Identifier; } +string combineTokens(ref const Token[] tokens) +{ + auto app = appender!string(); + foreach (t; tokens) + app.put(t.value); + return app.data; +} pure nothrow TokenType lookupTokenTypeOptimized(const string input) { diff --git a/types.d b/types.d index b52dddb..7f052cc 100644 --- a/types.d +++ b/types.d @@ -602,37 +602,60 @@ public: } -immutable(string[][string]) typeProperties; -immutable(string[]) floatProperties; -immutable(string[]) integralProperties; -immutable(string[]) commonProperties; -immutable(string[]) arrayProperties; +immutable(string[string][string]) typeProperties; // Yo dawg I heard you like maps... +immutable(string[string]) floatProperties; +immutable(string[string]) integralProperties; +immutable(string[string]) commonProperties; +immutable(string[string]) arrayProperties; static this() { - floatProperties = ["alignof", "dig", "epsilon", "im", "infinity", "init", - "mangleof", "mant_dig", "max", "max_10_exp", ".max_­exp", "min_10_­exp", - "min_­exp", "min_nor­mal", "nan", "re", "sizeof" + // <#> means "its own type" + // for example float.max is of type float + floatProperties = [ + "alignof" : "int", + "dig" : "<#>", + "epsilon" : "<#>", + "im" : "<#>", + "infinity" : "<#>", + "init" : "<#>", + "mangleof" : "string", + "mant_dig" : "int", + "max" : "<#>", + "max_10_exp" : "int", + "max_­exp" : "int", + "min_10_­exp" : "int", + "min_­exp" : "int", + "min_nor­mal" : "<#>", + "nan" : "<#>", + "re" : "<#>", + "sizeof" : "size_t" ]; - integralProperties = ["alignof", "init", "mangleof", "max", - "min", "sizeof", "stringof" + integralProperties = [ + "alignof" : "int", + "init" : "<#>", + "mangleof" : "string", + "max" : "<#>", + "min" : "<#>", + "sizeof" : "size_t", + "stringof" : "string" ]; commonProperties = [ - "alignof", - "init", - "mangleof", - "stringof" + "alignof" : "int", + "init" : "<#>", + "mangleof" : "string", + "stringof" : "string" ]; arrayProperties = [ - "alignof", - "init", - "length", - "mangleof", - "ptr", - "stringof", + "alignof" : "int", + "init" : "<#>", + "length" : "size_t", + "mangleof" : "string", + "ptr" : "<#>*", + "stringof" : "string", ]; typeProperties = [ @@ -678,6 +701,26 @@ public: Tuple!(string, string)[string] getMembersOfType(string name) { + // Arrays + if (name.length > 2 && name[$ - 2 .. $] == "[]") + { + Tuple!(string, string)[string] typeMap; + foreach(k, v; arrayProperties) + typeMap[k] = Tuple!(string, string)(v, "m"); + return typeMap; + } + + // Basic types + auto tp = name in typeProperties; + if (tp !is null) + { + Tuple!(string, string)[string] typeMap; + foreach (k, v; *tp) + typeMap[k] = Tuple!(string, string)(v.replace("<#>", name), "m"); + return typeMap; + } + + // User-defined types foreach (m; chain(modules, [currentModule])) { foreach (inherits; chain(m.interfaces, m.classes)) @@ -696,6 +739,7 @@ public: typeMap[k] = v; } } + typeMap["classInfo"] = Tuple!(string, string)("TypeInfo_Class", "m"); return typeMap; }