Changeset 1706

Timestamp:

10/25/08 01:25:20 (2 months ago)

Author:

Chuck.Esterbrook

Message:

Code cleanup.

Location:

cobra/trunk/Source

Files:

• BinaryOpExpr.cobra (modified) (2 diffs)
• Expr.cobra (modified) (3 diffs)
• Types.cobra (modified) (3 diffs)

cobra/trunk/Source/BinaryOpExpr.cobra

@@ -525 +525 @@
                         else if .op in ['IS', 'ISNOT']
                                 # Essentially "is" and "is not" are for reference types. Give a warning when used for value types.
-                                if not TypeUtil.isDynamicOrPassThrough(leftType) and not TypeUtil.isDynamicOrPassThrough(rightType)
+                                if not leftType.isDynamicOrPassThrough and not rightType.isDynamicOrPassThrough
                                         opName = if(.op=='IS', 'is', 'is not')
                                         altName = if(.op=='IS', '==', '<>')
@@ -533 +533 @@
                                                 .compiler.warning(this, 'Both the left and right sides of "[opName]" are value types ("[leftType.name]" and "[rightType.name]"), but "[opName]" applies to reference types. Use "[altName]" instead.')
                                         # interestingly, I don't think the following ever happen in practice...
-                                        else if not leftType.isReference and not TypeUtil.isNilableAndDescendantOf(rightType, leftType)
+                                        else if not leftType.isReference and not rightType.isNilableAndDescendantOf(leftType)
                                                 .compiler.warning(this, 'The left side of "[opName]" is a value type ("[leftType.name]") while the right side is an incompatible reference type ("[rightType.name]").')
-                                        else if not rightType.isReference and not TypeUtil.isNilableAndDescendantOf(leftType, rightType)
+                                        else if not rightType.isReference and not leftType.isNilableAndDescendantOf(rightType)
                                                 .compiler.warning(this, 'The right side of "[opName]" is a value type ("[rightType.name]") while the left side is an incompatible reference type ("[leftType.name]").')                                         
                 else

cobra/trunk/Source/Expr.cobra

@@ -181 +181 @@
                 body
                         base._bindImp
-
-        def _isSequence(type as IType) as bool
-                if type inherits NilableType
-                        return _isSequence(type.theWrappedType to passthrough)
-                # TODO: check for ISliceable which would have a .getSlice
-                if type.isDescendantOf(.compiler.stringType)
-                        return true
-                # if type.isDescendantOf(.compiler.arrayType)
-                if type inherits ArrayType
-                        return true
-                if type.isDescendantOf(.compiler.ilistType)
-                        return true
-                genericList = .compiler.listOfType
-                if type.isDescendantOf(genericList)
-                        return true
-                if type inherits Box
-                        if type.genericDef is genericList
-                                return true
-                genericIList = .compiler.ilistOfType
-                if type.isDescendantOf(genericIList)
-                        return true
-                if type inherits Box
-                        if type.genericDef is genericIList
-                                return true
-                if type.isDynamic
-                        return true
-                return false
 
         def _suggestionsMessage(suggs as List<of String>) as String
@@ -799 +772 @@
                 _what.bindImp  # bind first because it may be needed for type inference
                 whatType = _what.type to !
-                if not whatType.isDescendantOf(.compiler.enumerableType) and not _isSequence(whatType)  # TODO: can probably drop _isSequence
+                if not whatType.isDescendantOf(.compiler.enumerableType) and not whatType.isSequenceLike  # TODO: can probably drop .isSequenceLike
                         .throwError('Cannot enumerate values of type "[whatType.name]". You can enumerate anything enumerable (IEnumerable, IList, arrays, strings, etc.).')
                 _var = .bindVar(_nameExpr)
@@ -1739 +1712 @@
                         .compiler.recordError(ne)
                 success
-                        if not _isSequence(_target.type to !)
+                        if not _target.type.isSequenceLike
                                 .throwError('Cannot slice values of type "[_target.type.name]". You can slice strings, arrays, IList and IList<of>.')
                 if _start

cobra/trunk/Source/Types.cobra

@@ -1605 +1605 @@
 extend IType
 
+        def isDynamicOrPassThrough as bool
+                return this inherits DynamicType or this inherits PassThroughType
+
+        def isNilableAndDescendantOf(otherType as IType) as bool
+                return this inherits NilableType and ((this to NilableType).theWrappedType).isDescendantOf(otherType)
+
+        def isSequenceLike as bool
+                """
+                Returns true if the receiver is like a sequence, such as being an actual array, list, string, or a nilable version thereof.
+                The dynamic type will also return true because at compile-time, dynamic is considered to be like everything.
+                Requires Node.getCompiler
+                """
+                type = this
+                if type inherits NilableType
+                        return type.theWrappedType.isSequenceLike
+                # TODO: check for ISliceable which would have a .getSlice
+                tp = Node.getCompiler  # 'tp' for 'type provider'
+                if type.isDescendantOf(tp.stringType)
+                        return true
+                # if type.isDescendantOf(tp.arrayType)
+                if type inherits ArrayType
+                        return true
+                if type.isDescendantOf(tp.ilistType)
+                        return true
+                genericList = tp.listOfType
+                if type.isDescendantOf(genericList)
+                        return true
+                if type inherits Box
+                        if type.genericDef is genericList
+                                return true
+                genericIList = tp.ilistOfType
+                if type.isDescendantOf(genericIList)
+                        return true
+                if type inherits Box
+                        if type.genericDef is genericIList
+                                return true
+                if type.isDynamic
+                        return true
+                return false
+
         def isDictionaryLike as bool
                 """
@@ -1614 +1654 @@
                 if type inherits NilableType
                         return type.theWrappedType.isDictionaryLike
-                tp = Node.getCompiler  # TODO? expand ITypeProvider to cover idictionaryType, dictionaryOfType, idictionaryOfType
+                tp = Node.getCompiler  # 'tp' for 'type provider' # TODO? expand ITypeProvider to cover idictionaryType, dictionaryOfType, idictionaryOfType
                 if type.isDescendantOf(tp.idictionaryType)
                         return true
@@ -1635 +1675 @@
 
 class TypeUtil
+        """
+        If the utility involves primarily one instance of IType, or an instance of IType is the logical
+        "receiver" of a message, then add the utility method to "extend IType" above.
+        """
         
-        # TODO: should be interface extension on IType
-
         shared
-
-                def isDynamicOrPassThrough(t as IType) as bool
-                        return t inherits DynamicType or t inherits PassThroughType
-
-                def isNilableAndDescendantOf(t1 as IType, t2 as IType) as bool
-                        return t1 inherits NilableType and ((t1 to NilableType).theWrappedType).isDescendantOf(t2)
 
                 def dictionaryOf(genericParams as List<of IType>, typeArgs as IList<of IType>) as Dictionary<of GenericParam, IType>